RaSol

Communication with Extraterrestrial Intelligence

2006-09-27T11:43:00.000+03:00

Nu este o gluma. Este titlul unui raport NSA, ce face parte dintr-o lista mai lunga, recent declasificat.

Windows Vista's BitLocker Drive Encryption

2006-09-22T11:59:00.000+03:00

AES-CBC + Elephant diffuser algorithm
Daca folosesc laptop-ul:

pentru a calcula banii de cosnita si il pierd, probabil ca vecina nu va fi capabila sa afle pretul la varza murata
pentru a face o analiza de piata, probabil ca nici concurenta nu va fi in stare sa afle ceva

Daca am de a face cu domenii cu adevarat sensibile, probabil ca am grija sa nu pierd laptop-ul si in mod sigur folosesc unelte adevarate pentru a-mi proteja datele.

Bruce Scheneier, Security Engineering

2006-09-01T19:22:00.000+03:00

Nu am citit-o inca dar cred ca merita citita ... cartea

Ex: criptare fisier sau sir cu AES128, CBC, PKCS5Padding

2006-01-25T19:38:00.000+02:00

import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.io.*;
public class AES {
private byte functiune;
private Cipher cifrul;
SecretKey cheia;
byte[] IVul;
public AES(byte ceFunctiune , byte[] pCheia , byte[] PIVul) throws Exception{
functiune =ceFunctiune;
switch(functiune) {
case 'C': initCriptare();
break;
case 'D': initDecriptare( pCheia , PIVul );
break;
default: throw new Exception("apel gresit constructor AES");
}
}

private void initCriptare(){
try {
KeyGenerator kgen = KeyGenerator.getInstance("AES");
kgen.init(128);
cheia = kgen.generateKey();
//SecretKeyFactory fabrica = SecretKeyFactory.getInstance("AES");
cifrul = Cipher.getInstance("AES/CBC/PKCS5Padding");
cifrul.init(Cipher.ENCRYPT_MODE, cheia);
IVul = cifrul.getIV();
} catch ( NoSuchAlgorithmException e) {
System.out.println( "exceptie algoritm AES" );
} catch ( NoSuchPaddingException e ) {
System.out.println( "exceptie aliniere AES" );
} catch( InvalidKeyException e) {
System.out.println( "exceptie cheie AES" );
}
}

private void initDecriptare( byte[] pCheia , byte[] PIVul){
try {
cheia = new SecretKeySpec(pCheia, "AES");
IVul = PIVul.clone();
cifrul = Cipher.getInstance("AES/CBC/PKCS5Padding");
cifrul.init(Cipher.DECRYPT_MODE, cheia , new IvParameterSpec(IVul) );
} catch ( NoSuchAlgorithmException e) {
System.out.println( "exceptie algoritm AES" );
} catch ( NoSuchPaddingException e ) {
System.out.println( "exceptie aliniere AES" );
} catch( InvalidKeyException e) {
System.out.println( "exceptie cheie AES" );
} catch( InvalidAlgorithmParameterException e) {
System.out.println( "exceptie vector initializare AES" );
}

}

public byte[] getSpecificatiaCheii() {
return cheia.getEncoded();
}

public byte[] getIV() {
return IVul.clone();
}

public static String asHex (byte buf[]) {
StringBuffer strbuf = new StringBuffer(buf.length * 2);
int i;
for (i = 0; i < buf.length; i++) {
if (((int) buf[i] & 0xff) < 0x10)
strbuf.append("0");
strbuf.append(Long.toString((int) buf[i] & 0xff, 16));
}
return strbuf.toString();
}

public String actioneaza(byte pTip , String sursa , String destinatie) throws Exception {
String result = null;
switch(pTip) {
case 'F': switch(functiune) {
case 'C': try {
FileInputStream fin = new FileInputStream(sursa);
FileOutputStream fout = new FileOutputStream(destinatie);
encryptStream(fin, fout);
result = new String("criptat fisierul "+sursa+" in fisierul"+destinatie);
} catch (FileNotFoundException e) {
System.out.println("fisere negasite la criptare AES");
};
break;
case 'D': try {
FileInputStream fin = new FileInputStream(sursa);
FileOutputStream fout = new FileOutputStream(destinatie);
decryptStream(fin, fout);
result = new String("decriptat fisierul "+sursa+" in fisierul"+destinatie);
} catch (FileNotFoundException e) {
System.out.println("fisere negasite la decriptare AES");
};
break;
};
break;
case 'S': switch(functiune) {
case 'C': result = encryptString(sursa);
result = new String("criptat sirul "+sursa+" cu reprezentarea "+
asHex(sursa.getBytes())+" in sirul cu reprezentarea "+
asHex(result.getBytes()));
break;
case 'D': result = decryptString(sursa);
result = new String("decriptat sirul cu reprezentarea "+
asHex(sursa.getBytes())+" in sirul"+result+
"cu reprezentarea "+
asHex(result.getBytes()));
break;
}
break;
default: throw new Exception("apel gresit actioneaza AES");
}
return result;
}

// metoda criptare String
private String encryptString(String sursa) {
String result = null;
try {
// Encode the string into bytes using utf-8
byte[] utf8 = sursa.getBytes("UTF8");

// Encrypt
byte[] enc = cifrul.doFinal(utf8);

// Encode bytes to base64 to get a string
return new sun.misc.BASE64Encoder().encode(enc);
} catch (javax.crypto.BadPaddingException e) {
System.out.println("eroare aliniere la criptare sir AES");
} catch (IllegalBlockSizeException e) {
System.out.println("eroare dimenisune bloc la criptare sir AES");
} catch (UnsupportedEncodingException e) {
System.out.println("eroare codificare la criptare sir AES");
} catch (java.io.IOException e) {
System.out.println("eroare IO la criptare sir AES");
}
return result;
}

// metoda decriptare String
private String decryptString(String sursa) {
String result = null;
try {
byte[] dec = new sun.misc.BASE64Decoder().decodeBuffer(sursa);
byte[] utf8 = cifrul.doFinal(dec);
return new String(utf8, "UTF8");
} catch (javax.crypto.BadPaddingException e) {
System.out.println("eroare aliniere la decriptare sir AES");
} catch (IllegalBlockSizeException e) {
System.out.println("eroare dimenisune bloc la decriptare sir AES");
} catch (UnsupportedEncodingException e) {
System.out.println("eroare codificare la decriptare sir AES");
} catch (java.io.IOException e) {
System.out.println("eroare IO la decriptare sir AES");
}
return result;
}

// metoda criptare Stream
private void encryptStream(InputStream in, OutputStream out) {
byte[] buf = new byte[1024];
try {
out = new CipherOutputStream(out, cifrul);
int numRead = 0;
while ((numRead = in.read(buf)) >= 0) {
out.write(buf, 0, numRead);
}
out.close();
} catch (java.io.IOException e) {
}
}

// metoda decriptare Stream
private void decryptStream(InputStream in, OutputStream out) {
byte[] buf = new byte[1024];
try {
in = new CipherInputStream(in, cifrul);
int numRead = 0;
while ((numRead = in.read(buf)) >= 0) {
out.write(buf, 0, numRead);
}
out.close();
} catch (java.io.IOException e) {
}
}

}
public class TestAES{
public static void main(String[] args){
if (args.length == 2) {
try{
AES criptor = new AES((byte)'C', new String("").getBytes() , new String("").getBytes());
System.out.println("Cheia utilizata: "+AES.asHex(criptor.getSpecificatiaCheii()));
System.out.println("Vectorul de initializare: "+AES.asHex(criptor.getIV()));
System.out.println( criptor.actioneaza((byte)'F' , args[0] , args[1]) );
System.out.println( criptor.actioneaza((byte)'S' , args[0] , new String("")) );

byte[] spec = criptor.getSpecificatiaCheii();
byte[] iv = criptor.getIV();
AES decriptor = new AES((byte)'D', spec , iv);
String numeFisNou = new String(args[0]+"copie");
System.out.println( decriptor.actioneaza((byte)'F' , args[1] , numeFisNou) );
} catch(Exception e) {
System.out.println(e.toString());
}
} else {
System.out.println("apelul este de forma: TestAES fisierIntrare fisierIesire");
}
}
}

Ex: listarea serviciilor

2006-01-25T12:51:00.000+02:00

codul sursa
import java.util.*;
import java.security.*;
import javax.crypto.*;
import java.io.*;

public class ListareServicii{

// metoda ce returneaza serviciile pentru toti furnizorii de servicii de criptografie instalati
// sub forma unui array de String-uri
public static String[] getServiceTypes() {
Set result = new HashSet();
Provider[] providers = Security.getProviders();
// si pentru fiecare
for (int i=0; i<providers.length; i++) {
// construiesc lista cu descrierile native ale serviciilor
Set serviciile = providers[i].getServices();
for ( Iterator it=serviciile.iterator(); it.hasNext(); ) {
Provider.Service serviciul = (Provider.Service)it.next();
result.add(serviciul.toString());
}
}
return (String[])result.toArray(new String[result.size()]);
}

// main-ul
public static void main(String[] argumente) {

// afisare servicii si implementarile lor
ListareServicii testul = new ListareServicii();
String[] serviciile = testul.getServiceTypes();
for (int i=0; i<serviciile.length; i++) {
System.out.println("Serviciul este: "+serviciile[i]);
}
}

}
exemplu rulare
- Serviciul este: SunJCE: Cipher.PBEWithSHA1AndRC2_40 -> com.sun.crypto.provider.PKCS12PBECipherCore$PBEWithSHA1AndRC2_40 aliases: [OID.1.2.840.113549.1.12.1.6, 1.2.840.113549.1.12.1.6]
- Serviciul este: SunJCE: AlgorithmParameters.DESede -> com.sun.crypto.provider.DESedeParameters aliases: [TripleDES]
- Serviciul este: SunJCE: SecretKeyFactory.DES -> com.sun.crypto.provider.DESKeyFactory
- Serviciul este: SunSASL: SaslServerFactory.DIGEST-MD5 -> com.sun.security.sasl.digest.FactoryImpl
- Serviciul este: SunJCE: SecretKeyFactory.PBEWithMD5AndDES -> com.sun.crypto.provider.PBEKeyFactory aliases: [OID.1.2.840.113549.1.5.3, 1.2.840.113549.1.5.3]
- Serviciul este: SunJCE: Mac.HmacSHA256 -> com.sun.crypto.provider.HmacCore$HmacSHA256 attributes: {SupportedKeyFormats=RAW}
- Serviciul este: SunJSSE: SSLContext.SSLv3 -> com.sun.net.ssl.internal.ssl.SSLContextImpl
- Serviciul este: SunJSSE: TrustManagerFactory.PKIX -> com.sun.net.ssl.internal.ssl.TrustManagerFactoryImpl$PKIXFactory aliases: [SunPKIX, X509, X.509]
- Serviciul este: SunRsaSign: Signature.SHA1withRSA -> sun.security.rsa.RSASignature$SHA1withRSA aliases: [1.2.840.113549.1.1.5, OID.1.2.840.113549.1.1.5, 1.3.14.3.2.29] attributes: {SupportedKeyClasses=java.security.interfaces.RSAPublicKey|java.security.interfaces.RSAPrivateKey}
- Serviciul este: SunJCE: KeyGenerator.DESede -> com.sun.crypto.provider.DESedeKeyGenerator aliases: [TripleDES]
- Serviciul este: SunJCE: KeyGenerator.ARCFOUR -> com.sun.crypto.provider.KeyGeneratorCore$ARCFOURKeyGenerator aliases: [RC4]
- Serviciul este: SunJCE: AlgorithmParameters.DES -> com.sun.crypto.provider.DESParameters
- Serviciul este: SUN: MessageDigest.MD2 -> sun.security.provider.MD2
- Serviciul este: SunJSSE: SSLContext.TLS -> com.sun.net.ssl.internal.ssl.SSLContextImpl
- Serviciul este: SunJCE: AlgorithmParameters.PBEWithSHA1AndRC2_40 -> com.sun.crypto.provider.PBEParameters aliases: [OID.1.2.840.113549.1.12.1.6, 1.2.840.113549.1.12.1.6]
- Serviciul este: SUN: CertificateFactory.X.509 -> sun.security.provider.X509Factory aliases: [X509] attributes: {ImplementedIn=Software}
- Serviciul este: SunJSSE: Signature.MD2withRSA -> sun.security.rsa.RSASignature$MD2withRSA aliases: [1.2.840.113549.1.1.2, OID.1.2.840.113549.1.1.2]
- Serviciul este: SunJCE: Cipher.ARCFOUR -> com.sun.crypto.provider.ARCFOURCipher aliases: [RC4] attributes: {SupportedModes=ECB, SupportedKeyFormats=RAW, SupportedPaddings=NOPADDING}
- Serviciul este: SunJCE: Cipher.RSA -> com.sun.crypto.provider.RSACipher attributes: {SupportedModes=ECB, SupportedKeyClasses=java.security.interfaces.RSAPublicKey|java.security.interfaces.RSAPrivateKey, SupportedPaddings=NOPADDING|PKCS1PADDING|OAEPWITHMD5ANDMGF1PADDING|OAEPWITHSHA1ANDMGF1PADDING|OAEPWITHSHA-1ANDMGF1PADDING|OAEPWITHSHA-256ANDMGF1PADDING|OAEPWITHSHA-384ANDMGF1PADDING|OAEPWITHSHA-512ANDMGF1PADDING}
- Serviciul este: SUN: KeyStore.JKS -> sun.security.provider.JavaKeyStore$JKS attributes: {ImplementedIn=Software}
- Serviciul este: SunJCE: Mac.HmacSHA384 -> com.sun.crypto.provider.HmacCore$HmacSHA384 attributes: {SupportedKeyFormats=RAW}
- Serviciul este: SunJCE: KeyGenerator.AES -> com.sun.crypto.provider.AESKeyGenerator aliases: [Rijndael]
- Serviciul este: SUN: Signature.NONEwithDSA -> sun.security.provider.DSA$RawDSA aliases: [RawDSA] attributes: {SupportedKeyClasses=java.security.interfaces.DSAPublicKey|java.security.interfaces.DSAPrivateKey}
- Serviciul este: SunJCE: Cipher.Blowfish -> com.sun.crypto.provider.BlowfishCipher attributes: {SupportedModes=ECB|CBC|PCBC|CTR|CFB|OFB|CFB8|CFB16|CFB24|CFB32|CFB40|CFB48|CFB56|CFB64|OFB8|OFB16|OFB24|OFB32|OFB40|OFB48|OFB56|OFB64, SupportedKeyFormats=RAW, SupportedPaddings=NOPADDING|PKCS5PADDING|ISO10126PADDING}
- Serviciul este: SunJGSS: GssApiMechanism.1.2.840.113554.1.2.2 -> sun.security.jgss.krb5.Krb5MechFactory
- Serviciul este: SunJCE: SecretKeyFactory.DESede -> com.sun.crypto.provider.DESedeKeyFactory aliases: [TripleDES]
- Serviciul este: SunJCE: KeyGenerator.Blowfish -> com.sun.crypto.provider.BlowfishKeyGenerator
- Serviciul este: SunJCE: KeyGenerator.RC2 -> com.sun.crypto.provider.KeyGeneratorCore$RC2KeyGenerator
- Serviciul este: SunJCE: Cipher.DESedeWrap -> com.sun.crypto.provider.DESedeWrapCipher attributes: {SupportedModes=CBC, SupportedKeyFormats=RAW, SupportedPaddings=NOPADDING}
- Serviciul este: SunJCE: AlgorithmParameters.RC2 -> com.sun.crypto.provider.RC2Parameters
- Serviciul este: SunJCE: Cipher.AES -> com.sun.crypto.provider.AESCipher aliases: [Rijndael] attributes: {SupportedModes=ECB|CBC|PCBC|CTR|CFB|OFB|CFB8|CFB16|CFB24|CFB32|CFB40|CFB48|CFB56|CFB64|OFB8|OFB16|OFB24|OFB32|OFB40|OFB48|OFB56|OFB64|CFB72|CFB80|CFB88|CFB96|CFB104|CFB112|CFB120|CFB128|OFB72|OFB80|OFB88|OFB96|OFB104|OFB112|OFB120|OFB128, SupportedKeyFormats=RAW, SupportedPaddings=NOPADDING|PKCS5PADDING|ISO10126PADDING}
- Serviciul este: SunJCE: KeyGenerator.HmacMD5 -> com.sun.crypto.provider.HmacMD5KeyGenerator
- Serviciul este: SunJCE: Mac.HmacMD5 -> com.sun.crypto.provider.HmacMD5 attributes: {SupportedKeyFormats=RAW}
- Serviciul este: SUN: MessageDigest.MD5 -> sun.security.provider.MD5 attributes: {ImplementedIn=Software}
- Serviciul este: SunRsaSign: Signature.SHA512withRSA -> sun.security.rsa.RSASignature$SHA512withRSA aliases: [1.2.840.113549.1.1.13, OID.1.2.840.113549.1.1.13] attributes: {SupportedKeyClasses=java.security.interfaces.RSAPublicKey|java.security.interfaces.RSAPrivateKey}
- Serviciul este: SUN: CertStore.LDAP -> sun.security.provider.certpath.LDAPCertStore attributes: {ImplementedIn=Software, LDAPSchema=RFC2587}
- Serviciul este: SunJSSE: TrustManagerFactory.SunX509 -> com.sun.net.ssl.internal.ssl.TrustManagerFactoryImpl$SimpleFactory
- Serviciul este: SUN: SecureRandom.SHA1PRNG -> sun.security.provider.SecureRandom attributes: {ImplementedIn=Software}
- Serviciul este: SunJCE: Cipher.PBEWithMD5AndTripleDES -> com.sun.crypto.provider.PBEWithMD5AndTripleDESCipher
- Serviciul este: SunJCE: KeyStore.JCEKS -> com.sun.crypto.provider.JceKeyStore
- Serviciul este: SunJCE: AlgorithmParameters.Blowfish -> com.sun.crypto.provider.BlowfishParameters
- Serviciul este: SunJCE: SecretKeyFactory.PBEWithSHA1AndRC2_40 -> com.sun.crypto.provider.PBEKeyFactory aliases: [OID.1.2.840.113549.1.12.1.6, 1.2.840.113549.1.12.1.6]
- Serviciul este: SunJCE: Cipher.RC2 -> com.sun.crypto.provider.RC2Cipher attributes: {SupportedModes=ECB|CBC|PCBC|CTR|CFB|OFB|CFB8|CFB16|CFB24|CFB32|CFB40|CFB48|CFB56|CFB64|OFB8|OFB16|OFB24|OFB32|OFB40|OFB48|OFB56|OFB64, SupportedKeyFormats=RAW, SupportedPaddings=NOPADDING|PKCS5PADDING|ISO10126PADDING}
- Serviciul este: SunJSSE: Signature.MD5andSHA1withRSA -> com.sun.net.ssl.internal.ssl.RSASignature
- Serviciul este: SunJCE: SecretKeyFactory.PBEWithSHA1AndDESede -> com.sun.crypto.provider.PBEKeyFactory aliases: [OID.1.2.840.113549.1.12.1.3, 1.2.840.113549.1.12.1.3]
- Serviciul este: SunJCE: KeyGenerator.HmacSHA1 -> com.sun.crypto.provider.HmacSHA1KeyGenerator
- Serviciul este: SunJCE: AlgorithmParameters.PBEWithMD5AndTripleDES -> com.sun.crypto.provider.PBEParameters
- Serviciul este: SunJSSE: KeyManagerFactory.SunX509 -> com.sun.net.ssl.internal.ssl.KeyManagerFactoryImpl$SunX509
- Serviciul este: SunJCE: AlgorithmParameters.PBEWithMD5AndDES -> com.sun.crypto.provider.PBEParameters aliases: [OID.1.2.840.113549.1.5.3, 1.2.840.113549.1.5.3]
- Serviciul este: SUN: Signature.SHA1withDSA -> sun.security.provider.DSA$SHA1withDSA aliases: [DSA, DSS, SHA/DSA, SHA-1/DSA, SHA1/DSA, SHAwithDSA, DSAWithSHA1, OID.1.2.840.10040.4.3, 1.2.840.10040.4.3, 1.3.14.3.2.13, 1.3.14.3.2.27] attributes: {ImplementedIn=Software, KeySize=1024, SupportedKeyClasses=java.security.interfaces.DSAPublicKey|java.security.interfaces.DSAPrivateKey}
- Serviciul este: SunRsaSign: Signature.MD2withRSA -> sun.security.rsa.RSASignature$MD2withRSA aliases: [1.2.840.113549.1.1.2, OID.1.2.840.113549.1.1.2] attributes: {SupportedKeyClasses=java.security.interfaces.RSAPublicKey|java.security.interfaces.RSAPrivateKey}
- Serviciul este: SunRsaSign: Signature.MD5withRSA -> sun.security.rsa.RSASignature$MD5withRSA aliases: [1.2.840.113549.1.1.4, OID.1.2.840.113549.1.1.4] attributes: {SupportedKeyClasses=java.security.interfaces.RSAPublicKey|java.security.interfaces.RSAPrivateKey}
- Serviciul este: SunJCE: Mac.HmacSHA512 -> com.sun.crypto.provider.HmacCore$HmacSHA512 attributes: {SupportedKeyFormats=RAW}
- Serviciul este: SunJCE: AlgorithmParameterGenerator.DiffieHellman -> com.sun.crypto.provider.DHParameterGenerator aliases: [DH, OID.1.2.840.113549.1.3.1, 1.2.840.113549.1.3.1]
- Serviciul este: SUN: CertPathValidator.PKIX -> sun.security.provider.certpath.PKIXCertPathValidator attributes: {ImplementedIn=Software, ValidationAlgorithm=RFC3280}
- Serviciul este: SUN: CertStore.Collection -> sun.security.provider.certpath.CollectionCertStore attributes: {ImplementedIn=Software}
- Serviciul este: SunJCE: Cipher.AESWrap -> com.sun.crypto.provider.AESWrapCipher attributes: {SupportedModes=ECB, SupportedKeyFormats=RAW, SupportedPaddings=NOPADDING}
- Serviciul este: SunJCE: AlgorithmParameters.DiffieHellman -> com.sun.crypto.provider.DHParameters aliases: [DH, OID.1.2.840.113549.1.3.1, 1.2.840.113549.1.3.1]
- Serviciul este: SUN: CertStore.com.sun.security.IndexedCollection -> sun.security.provider.certpath.IndexedCollectionCertStore attributes: {ImplementedIn=Software}
- Serviciul este: SunJCE: AlgorithmParameters.PBEWithSHA1AndDESede -> com.sun.crypto.provider.PBEParameters aliases: [OID.1.2.840.113549.1.12.1.3, 1.2.840.113549.1.12.1.3]
- Serviciul este: SunSASL: SaslClientFactory.DIGEST-MD5 -> com.sun.security.sasl.digest.FactoryImpl
- Serviciul este: SunRsaSign: KeyPairGenerator.RSA -> sun.security.rsa.RSAKeyPairGenerator aliases: [1.2.840.113549.1.1, OID.1.2.840.113549.1.1]
- Serviciul este: SunJSSE: Signature.MD5withRSA -> sun.security.rsa.RSASignature$MD5withRSA aliases: [1.2.840.113549.1.1.4, OID.1.2.840.113549.1.1.4]
- Serviciul este: SUN: AlgorithmParameters.DSA -> sun.security.provider.DSAParameters aliases: [1.3.14.3.2.12, 1.2.840.10040.4.1] attributes: {ImplementedIn=Software}
- Serviciul este: SunSASL: SaslClientFactory.EXTERNAL -> com.sun.security.sasl.ClientFactoryImpl
- Serviciul este: SUN: KeyFactory.DSA -> sun.security.provider.DSAKeyFactory aliases: [1.3.14.3.2.12, 1.2.840.10040.4.1] attributes: {ImplementedIn=Software}
- Serviciul este: SUN: MessageDigest.SHA-256 -> sun.security.provider.SHA2
- Serviciul este: SunJCE: SecretKeyFactory.PBEWithMD5AndTripleDES -> com.sun.crypto.provider.PBEKeyFactory
- Serviciul este: SunJCE: Mac.HmacSHA1 -> com.sun.crypto.provider.HmacSHA1 attributes: {SupportedKeyFormats=RAW}
- Serviciul este: SunJCE: AlgorithmParameters.OAEP -> com.sun.crypto.provider.OAEPParameters
- Serviciul este: SunJCE: Cipher.PBEWithSHA1AndDESede -> com.sun.crypto.provider.PKCS12PBECipherCore$PBEWithSHA1AndDESede aliases: [OID.1.2.840.113549.1.12.1.3, 1.2.840.113549.1.12.1.3]
- Serviciul este: SunJCE: KeyGenerator.HmacSHA512 -> com.sun.crypto.provider.KeyGeneratorCore$HmacSHA512KG
- Serviciul este: SunJCE: KeyGenerator.DES -> com.sun.crypto.provider.DESKeyGenerator
- Serviciul este: SunJCE: KeyGenerator.HmacSHA256 -> com.sun.crypto.provider.KeyGeneratorCore$HmacSHA256KG
- Serviciul este: SunJSSE: SSLContext.SSL -> com.sun.net.ssl.internal.ssl.SSLContextImpl
- Serviciul este: SUN: CertPathBuilder.PKIX -> sun.security.provider.certpath.SunCertPathBuilder attributes: {ImplementedIn=Software, ValidationAlgorithm=RFC3280}
- Serviciul este: SunJCE: Cipher.DES -> com.sun.crypto.provider.DESCipher attributes: {SupportedModes=ECB|CBC|PCBC|CTR|CFB|OFB|CFB8|CFB16|CFB24|CFB32|CFB40|CFB48|CFB56|CFB64|OFB8|OFB16|OFB24|OFB32|OFB40|OFB48|OFB56|OFB64, SupportedKeyFormats=RAW, SupportedPaddings=NOPADDING|PKCS5PADDING|ISO10126PADDING}
- Serviciul este: SunRsaSign: Signature.SHA256withRSA -> sun.security.rsa.RSASignature$SHA256withRSA aliases: [1.2.840.113549.1.1.11, OID.1.2.840.113549.1.1.11] attributes: {SupportedKeyClasses=java.security.interfaces.RSAPublicKey|java.security.interfaces.RSAPrivateKey}
- Serviciul este: SunJSSE: KeyStore.PKCS12 -> com.sun.net.ssl.internal.ssl.PKCS12KeyStore
- Serviciul este: SUN: MessageDigest.SHA-384 -> sun.security.provider.SHA5$SHA384
- Serviciul este: SUN: KeyPairGenerator.DSA -> sun.security.provider.DSAKeyPairGenerator aliases: [OID.1.2.840.10040.4.1, 1.2.840.10040.4.1, 1.3.14.3.2.12] attributes: {ImplementedIn=Software, KeySize=1024}
- Serviciul este: SunJCE: Cipher.PBEWithMD5AndDES -> com.sun.crypto.provider.PBEWithMD5AndDESCipher aliases: [OID.1.2.840.113549.1.5.3, 1.2.840.113549.1.5.3]
- Serviciul este: SunSASL: SaslServerFactory.GSSAPI -> com.sun.security.sasl.gsskerb.FactoryImpl
- Serviciul este: SunJCE: SecretKeyFactory.PBE -> com.sun.crypto.provider.PBEKeyFactory
- Serviciul este: SunJCE: Cipher.DESede -> com.sun.crypto.provider.DESedeCipher aliases: [TripleDES] attributes: {SupportedModes=ECB|CBC|PCBC|CTR|CFB|OFB|CFB8|CFB16|CFB24|CFB32|CFB40|CFB48|CFB56|CFB64|OFB8|OFB16|OFB24|OFB32|OFB40|OFB48|OFB56|OFB64, SupportedKeyFormats=RAW, SupportedPaddings=NOPADDING|PKCS5PADDING|ISO10126PADDING}
- Serviciul este: SUN: MessageDigest.SHA -> sun.security.provider.SHA aliases: [SHA-1, SHA1] attributes: {ImplementedIn=Software}
- Serviciul este: SunJSSE: KeyFactory.RSA -> sun.security.rsa.RSAKeyFactory aliases: [1.2.840.113549.1.1, OID.1.2.840.113549.1.1]
- Serviciul este: SunSASL: SaslClientFactory.CRAM-MD5 -> com.sun.security.sasl.ClientFactoryImpl
- Serviciul este: SunJSSE: KeyManagerFactory.NewSunX509 -> com.sun.net.ssl.internal.ssl.KeyManagerFactoryImpl$X509
- Serviciul este: SunJCE: Mac.HmacPBESHA1 -> com.sun.crypto.provider.HmacPKCS12PBESHA1 attributes: {SupportedKeyFormats=RAW}
- Serviciul este: SunSASL: SaslClientFactory.GSSAPI -> com.sun.security.sasl.gsskerb.FactoryImpl
- Serviciul este: SunJSSE: SSLContext.TLSv1 -> com.sun.net.ssl.internal.ssl.SSLContextImpl
- Serviciul este: SunRsaSign: KeyFactory.RSA -> sun.security.rsa.RSAKeyFactory aliases: [1.2.840.113549.1.1, OID.1.2.840.113549.1.1]
- Serviciul este: SunJCE: AlgorithmParameters.PBE -> com.sun.crypto.provider.PBEParameters
- Serviciul este: SUN: MessageDigest.SHA-512 -> sun.security.provider.SHA5$SHA512
- Serviciul este: SunJCE: KeyFactory.DiffieHellman -> com.sun.crypto.provider.DHKeyFactory aliases: [DH, OID.1.2.840.113549.1.3.1, 1.2.840.113549.1.3.1]
- Serviciul este: SunSASL: SaslServerFactory.CRAM-MD5 -> com.sun.security.sasl.ServerFactoryImpl
- Serviciul este: SunJCE: KeyGenerator.HmacSHA384 -> com.sun.crypto.provider.KeyGeneratorCore$HmacSHA384KG
- Serviciul este: SunJCE: KeyAgreement.DiffieHellman -> com.sun.crypto.provider.DHKeyAgreement aliases: [DH, OID.1.2.840.113549.1.3.1, 1.2.840.113549.1.3.1] attributes: {SupportedKeyClasses=javax.crypto.interfaces.DHPublicKey|javax.crypto.interfaces.DHPrivateKey}
- Serviciul este: SUN: KeyStore.CaseExactJKS -> sun.security.provider.JavaKeyStore$CaseExactJKS
- Serviciul este: SunJSSE: Signature.SHA1withRSA -> sun.security.rsa.RSASignature$SHA1withRSA aliases: [1.2.840.113549.1.1.5, OID.1.2.840.113549.1.1.5, 1.3.14.3.2.29, OID.1.3.14.3.2.29]
- Serviciul este: SunJSSE: KeyPairGenerator.RSA -> sun.security.rsa.RSAKeyPairGenerator aliases: [1.2.840.113549.1.1, OID.1.2.840.113549.1.1]
- Serviciul este: SunRsaSign: Signature.SHA384withRSA -> sun.security.rsa.RSASignature$SHA384withRSA aliases: [1.2.840.113549.1.1.12, OID.1.2.840.113549.1.1.12] attributes: {SupportedKeyClasses=java.security.interfaces.RSAPublicKey|java.security.interfaces.RSAPrivateKey}
- Serviciul este: SUN: AlgorithmParameterGenerator.DSA -> sun.security.provider.DSAParameterGenerator attributes: {ImplementedIn=Software, KeySize=1024}
- Serviciul este: SunSASL: SaslClientFactory.PLAIN -> com.sun.security.sasl.ClientFactoryImpl
- Serviciul este: SunJCE: AlgorithmParameters.AES -> com.sun.crypto.provider.AESParameters aliases: [Rijndael]
- Serviciul este: SunJCE: KeyPairGenerator.DiffieHellman -> com.sun.crypto.provider.DHKeyPairGenerator aliases: [DH, OID.1.2.840.113549.1.3.1, 1.2.840.113549.1.3.1]

Extensia de criptografie Java (JCE)

2006-01-24T15:06:00.000+02:00

Caracteristici generale
JCE implementeaza servicii criptografice specificate in cadrul mai larg al JCA (furrnizorul de servicii criptografice "SunJCE")
- cifrurile DES, Triple DES, Blowfish in modurile
  - ECB
  - CBC
  - CFB
  - OFB
  - PCBC
- generatoare de chei pentru
  - DES
  - Triple DES
  - Blowfish
  - HMAC-MD5
  - HMAC-SHA1
- MD5 cu PBE pentru DES-CBC (PKCS#5)
- generatoare de obiecte cheie si conversia catre/de la informatia de cheie pentru cifruri simetrice: DES, Triple DES si PBE si asimetrice: Diffie-Hellman
- acordul Diffie-Hellman asupra cheilor pentru mai multe entitati
- generator Diffie-Hellman de perechi de chei
- generator de parametri pentru algoritmul Diffie-Hellman
- implementare HMAC-MD5 si HMAC-SHA1 pentru algoritmi de hash (RFC 2104)
- implementare pentru schema de aliniere PKCS#5
- magazia de chei, JCEKS, pentru schema proprietara
si este un cadru de lucru (javax.crypto) care permite implementari proprietare pentru servicii criptografice.
Detalii
- Clase de baza
  - clasa cifru
    
    crearea unui obiect Cipher
    
    public static Cipher getInstance(String transformation)
    
    public static Cipher getInstance(String transformation , String provider)
    
    transformation este de forma
    
    "algorithm/mode/padding"
    
    "algorithm"
    
    ce au domeniile
    
    algorithm
    
    AES
    
    ARCFOUR/RC4
    
    Blowfish
    
    DES
    
    DESede
    
    ECIES
    
    PBEWith<digest>And<encryption> sau PBEWith<prf>And<encryption>
    
    RC2, RC4 sau RC5
    
    RSA
    
    mode
    
    NONE
    
    CBC (FIPS PUB 81)
    
    CFB (FIPS PUB 81)
    
    ECB (FIPS PUB 81)
    
    OFB (FIPS PUB 81)
    
    PCBC (Kerberos v4)
    
    padding
    
    ISO10126Padding
    
    NoPadding
    
    OAEPWith<digest>And<mgf>Padding (Optimal Asymmetric Encryption Padding, PKCS#1)
    
    PKCS5Padding
    
    SSL3Padding
  - initializarea unui obiect Cipher
    
    public void init(int opmode , Key key)
    
    public void init(int opmode , Certificate certificate )
    
    public void init(int opmode , Key key , SecureRandom random)
    
    public void init(int opmode , Certificate certificate , SecureRandom random)
    
    public void init(int opmode , Key key , AlgorithmParameterSpec params)
    
    public void init(int opmode , Key key , AlgorithmParameterSpec params, SecureRandom random)
    
    public void init(int opmode , Key key , AlgorithmParameters params)
    
    public void init(int opmode , Key key , AlgorithmParameters params, SecureRandom random)
    
    unde opmode are domeniul
    
    ENCRYPT_MODE
    criptare
    
    DECRYPT_MODE
    decriptare
    
    WRAP_MODE
    impachetarea cheii pentru transport
    
    UNWRAP_MODE
    despachetarea cheii intr-un obiect java.security.Key
  - criptarea si decriptarea
    
    intr-un singur pas
    
    public byte[] doFinal(byte[] input)
    
    public byte[] doFinal(byte[] input , int inputOffset , int inputLen)
    
    public byte[] doFinal(byte[] input , int inputOffset , int inputLen , byte[] output)
    
    public byte[] doFinal(byte[] input , int inputOffset , int inputLen , byte[] output , int outputOffset)
    
    in mai multi pas
    
    apel repetat pentru metodele
    
    public byte[] update(byte[] input)
    
    public byte[] update(byte[] input , int inputOffset , int inputLen)
    
    public byte[] update(byte[] input , int inputOffset , int inputLen , byte output)
    
    public byte[] update(byte[] input , int inputOffset , int inputLen , byte output , int outputOffset)
    
    urmate de un singur apel al
    
    public byte[] doFinal(byte[] input)
    
    public byte[] doFinal(byte[] input , int inputOffset , int inputLen)
    
    public byte[] doFinal(byte[] input , int inputOffset , int inputLen , byte[] output)
    
    public byte[] doFinal(byte[] input , int inputOffset , int inputLen , byte[] output , int outputOffset)
    
    public byte[] doFinal()
    
    public byte[] doFinal(byte[] input , int outputOffset)
    
    orice apel la o metoda doFinal reseteaza obiectul aducandu-l in starea de dupa initializare
  - impachetarea si despachetarea cheilor
    
    impachetarea
    public final byte[] wrap(Key key)
    
    despachetarea
    sunt necesare
    
    cheia impachetata
    
    numele algoritmului pentru cheie
    
    tipul cheii impachetate (Cipher.SECRET_KEY, Cipher.PRIVATE_KEY , Cipher.PUBLIC_KEY)
    
    public final Key unwrap(byte[] wrappedKey , String wrappedKeyAlgorithm , int wrappedKeyType)
  - gestionarea parametrilor algoritmului
  - consideratii asupra iesirii
    daca se utilizeaza una dintre metodele doFinal care permite specificarea buffer-ului de iesire se poate utiliza metoda
    public int getOutputSize(int inputLen)
    pentru a verifica daca acesta este suficient
- clase cifru fluide
  - clasa cifru fluid de intrare
    CipherInputStream
    este un FilterInputStream care foloseste un Cipher (care trebuie initializat inainte de utilizarea CipherInputStream);este importanta utilizarea doar a metodelor care au fost suprascrise sau definite in aceasta clasa;
  - clasa cifru fluid de iesire
    CipherOutputStream
- clasa generator de chei
  pentru algoritmi simetrici
  - crearea unui obiect KeyGenerator
    - public static KeyGenerator getInstance(String algorithm)
    - public static KeyGenerator getInstance(String algorithm , String provider)
    unde algorithm are domeniul
    - AES
    - ARCFOUR/RC4
    - Blowfish
    - DES
    - DESeed
    - HmacMD5
    - HmacSHA1
    - HmacSHA256
    - HmacSHA384
    - HmacSHA512
    - RC2
  - initializarea unui obiect KeyGenerator
    - initializare independenta de algoritm
      
      public void init (SecureRandom random)
      
      public void init(int keysize)
      
      public void init (int keysize , SecureRandom random)
    - initializare specifica unui algoritm
      
      public void init(AlgorithmParameterSpec params)
      
      public void init(AlgorithmParameterSpec params , SecureRandom random)
  - crearea unei chei
    public SecretKey generateKey()
- clasa convertor obiecte cheie/specificatii de cheie pentru chei simetrice
  - un obiect javax.crypto.SecretKeyFactory lucreaza pe chei simetrice
  - un obiect java.security.KeyFactory lucreaza pe o pereche de chei asimetrice
- clasa obiect sigilat
  un obiect a carui confidentialitate este asigurata de un algoritm criptografic
- clasa acord asupra cheilor
  asigura functionalitatea unui protocol de acord asupra cheilor
  cheile implicate implicate in distributia unui secret sunt create
  - de catre generatoare de chei: KeyPairGenerator, KeyGenerator
  - de catre KeyFactory
  - ca rezultat al unei faze intermediare a unui protocol de acord asupra cheilor
  utilizare
  - crearea unui obiect KeyAgreement
    
    public static KeyAgreement getInstance(String algorithm)
    
    public static KeyAgreement getInstance(String algorithm , String provider)
    
    algorithm avand domeniul
    
    DiffieHellman (PKCS#3)
    
    ECDH (Elliptic Curve Diffie-Hellman, RFC3278)
    
    ECMQV (Elliptic Curve Menezes-Qu-Vanstone)
  - initializarea unui obiect KeyAgreement
    initializarea se face cu o cheie privata si suplimentar prin specificarea unei surse pseudoaleatoare si a unei multimi de parametri de algoritm
    
    public void init(Key key)
    
    public void init(Key key , SecureRandom random)
    
    public void init(Key key , AlgorithmParameterSpec params)
    
    public void init(Key key , AlgorithmParameterSpec params , SecureRandom random)
  - realizarea fazei de acord
    rularea cel putin o data a metodei
    public Key doPhase(Key key , boolean lastPhase)
    pentru care key este o cheie publica sau o cheie interemediara generata in faza anterioara
  - generarea secretului partajat
    prin apelul uneia din metodele
    
    public byte[] generateSecret()
    
    public int generateSecret(byte[] sharedSecret , int offset)
    
    public SecretKey generateSecret(String algorithm)
- clasa cod de autentificare mesaj
  - crearea unui obiect Mac
    
    public static Mac getInstance(String algorithm)
    
    public static Mac getInstance(String algorithm , String provider)
    
    unde algorithm are domeniul
    
    HmacMD5
    
    HmacSHA1
    
    HmacSHA256
    
    HmacSHA384
    
    HmacSHA512
    
    PBEWith<mac>
  - initializarea unui obiect Mac
    
    public void init(Key key)
    
    public void init(Key key , AlgorithmParameterSpec params)
    
    key este un obiect care implementeaza interfata javax.crypto.SecretKey
  - calcularea valorii de MAC
    
    intr-un singur pas
    public byte[] doFinal(byte[] input)
    
    in mai multi pasi
    apel repetat la una dintre metodele
    
    public void update(byte input)
    
    public void update(byte[] input)
    
    public void update(byte[] input , int inputOffset , int inputLen)
    
    si un apel de terminare la una dintre metodele
    
    public byte[] doFinal()
    
    public byte[] doFinal(byte[] input)
    
    public byte[] doFinal(byte[] output , int outOffset)

Arhitectura de criptografie JAVA

2006-01-24T15:05:00.000+02:00

JCA (Java Cryptography Architecture): este un cadru de lucru ce permite accesarea si dezvoltarea de functiuni criptografice in platforma Java
obiective

independenta implementarii si interoperabilitate

independenta algoritmilor si extensibilitate
serviciu criptografic: un algoritm sau un tip care fie asigura operatii criptografice (ex: semnaturi digitale) fie genereaza sau furnizeaza informatie criptografica (ex: chei sau parametri) fie genereaza obiecte date (ex: magazii de chei sau certificate) care incapsuleaza chei
furnizor de servicii criptografice: un pachet care implementeaza o submultime a cerintelor prevazute in "Security Architecture" legate de criptografie
furnizorul implicit de servicii criptografice - SunJCE: este implementat de Sun si include implementari pentru:

DSA

MD5 si SHA-1

generator de perechi de chei publica/privata prin algoritmul DSA

generator de parametri prin algoritmul DSA

gestionar de parametri generati prin algoritmul DSA

generator de chei prin algoritmul DSA cu facilitate de conversie intre perechile de chei publica/privata si informatia de cheie

generator de numere pseudoaleatoare conform cu IEEE-P1363

constructor de cai de certificare (X.509) si validator pentru infrastructura de chei publice (cu revocare prin liste - CRL)

stocarea si revocarea certificatelor prin CRL si LDAP

generator de certificate X.509 si CRL

stocare de chei pentru stocare proprietara - JKS

marimile implicite ale cheilor
generator de cheie

DES: 56 biti

TripleDES: 112 biti

Blowfish: 56 biti

HmacMD5: 64 biti

HmacSHA1: 64 biti

generator de perechi de chei
Diffie-Hellman: 1024 biti

generator parametri algoritm
Diffie-Hellman: 1024 biti
clasa motor: defineste un serviciu criptografic intr-o maniera abstracta; o asemenea clasa asigura o interfata (interfata abstracta SPI - Service Provider Interface) pentru un tip de serviciu criptografic specificat; o instanta a unei clase motor ( contine ca un camp membru privat o instanta a clasei SPI corespondente care are acelasi nume cu cel al clasei motor) se creeaza printr-un apel la metoda getInstance a clasei motor; clasele SPI sunt abstracte astfel ca un furnizor de servicii criptografice trebuie sa contina clase derivate si implementari ale metodelor abstracte
JCA contine: clasele din pachetul "Java SDK Security" legate de criptografie

Provider
este interfata catre furnizorul de servicii criptografice
realizeaza inregistrarea serviciilor criptografice si poate fi folosita pentru a inregistra servicii de securitate
la crearea unei instante pentru o clasa motor se poate specifica optional furnizorul de servicii criptografice; daca nu se specifica, metoda getInstance cauta furnizorii care implementeaza serviciul criptografic cerut asociat cu numele algoritmului; Orice JVM are o lista de preferinte pentru aceasta cautare
instalarea unui furnizor de servicii criptografice
instalarea
inserarea in "classpath" a cai unde se afla jar-ul sau zip-ul

configurarea
se insereaza in fisierul java.security o linie "security.provider.n = masterClassName"

metode
public String getName()

public double getVersion()

public String getInfo()

Security
contine metode statice, nu se instantiaza si gestioneaza furnizorii de servicii criptografice si setarile generale de securitate care pot fi apelate numai in programe de incredere
un program de incredere este:

o aplicatie locala care ruleaza sub un gestionar de securitate

un applet sau o aplicatie care are drepturi de rulare a acestor metode

codul rulat are o sursa care poate fi URL-ul dar poate fi o referinta catre cheia publica corespunzatoare cheii private utilizate pentru semnarea codului; cheile publice sunt referite prin aliasuri din magazia de stocare
intr-un fisier de configurare a politicii, codul sursa este reprezentat prin URL si alias
ex:
grant codeBase "...", signedBy "..." (
permission java.security.SecurityPermisssion "insertProvider.";

permission java.security.SecurityPermisssion "removeProvider.";

permission java.security.SecurityPermisssion "putProviderProperty.";
};

metode
gestionarea furnizorilor

functie nume metoda obs.

interogare static Provider[] getProvider() ordinea in vector este data de ordinea de preferinta a furnizorilor

interogare static Provider getProvider(Stirng providerName)

adaugare static int addProvider(Provider provider) adauga la sfarsitul listei si returneaza ordine de preferinta sau -1 daca furnizorul exista deja

adaugare insertProviderAt(Provider provider , int position) insereaza in lista la pozitia "position", aluneca in jos restul listei si returneaza ordinea de preferinta

stergere static void removeProvider(String name) dupa stergerea furnizorului componentele listei sunt alunecate in fata cu o pozitie

proprietati de securitate

static String getProperty(String key)

static String setProperty(String key , String datum)

clase motor

MessageDigest
calcularea unei valori de hash

crearea unui obiect MessageDigest

static MessageDigest getInstance(String algorithm)

static MessageDigest getInstance(String algorithm , String provider)

static MessageDigest getInstance(String algorithm , Provider provider)

incarcarea mesajului in obiectul creat

void update(byte input)

void update(byte[] input)

void update(byte[] input , int offset , int len)

calcularea valorii de hash

byte[] digest()

byte[] digest(byte[] input)

byte[] digest(byte[] input , int offset , int len)

Signature
semnarea si verificarea digitala
un obiect Signature este modal (este intotdeauna intr-o stare data si poate face o singura operatie)
starile unui obiect Signature
UNINITIALIZED - starea imediat la crearea obiectului

SIGN - obiect pentru semnare

VERIFY - obiect pentru verificare verificare

crearea unui obiect Signature

static Signature getInstance(String algorithm)

static Signature getInstance(String algorithm , String provider)

static Signature getInstance(String algorithm , Provider provider)

initializarea unui obiect Signature

final void initSign(PrivateKey privateKey) - obiectul este pus in starea SIGN

final void initVerify(PublicKey publicKey) - obiectul este pus in starea VERIFY

final void initVerify(Certificate certificate) - obiectul este pus in starea VERIFY
acelasi obiect poate fi folosit si la semnare si la verificare

semnarea
incarcarea cu date
final void update(byte b)

final void update(byte[] data)

final void update(byte[] data , int off , int len)

generarea semnaturii
final byte[] sign()

final int sign(byte[] outbuf , int offset , int len)

verificarea
incarcarea cu date
final void update(byte b)

final void update(byte[] data)

final void update(byte[] data , int off , int len)
dupa apel obiectul ajunge in starea SIGN

generarea semnaturii
final boolean verify(byte[] signature)

final boolean verify(byte[] signature , int offset , int length)
dupa apel obiectul ajunge in starea VERIFY

KeyPairGenerator
generarea unei perechi de chei publica/privata

crearea unui obiect KeyPairGenerator

static KeyPairGenerator getInstance(String algorithm)

static KeyPairGenerator getInstance(String algorithm , String provider)

static KeyPairGenerator getInstance(String algorithm , Provider provider)

initializarea unui obiect KeyPairGenerator

independent de algoritm

void initialize(int keysize , SecureRandom random)

void initialize(int keysize)
este la latitudinea furnizorului ceea ce se intampla cu parametrii specifici algoritmului

specific unui algoritm

void initialize (AlgorithmParameterSpec params , SecureRandom random)

void initialize (AlgorithmParameterSpec params)

generarea unei perechi de chei
KeyPair generateKeyPair()

KeyFactory
conversia intre tipul criptografic Key si specificatiile de cheie care sunt reprezentari transparente ale informatiile de cheie
un asemenea obiect poate fi utilizat la conversia intre specificatii compatibile de chei

crearea unui obiect KeyFactory

static KeyFactory getInstance(String algorithm)

static KeyFactory getInstance(String algorithm , String provider)

static KeyFactory getInstance(String algorithm , Provider provider)

conversia de la o specificatie de cheie la un obiect cheie

PublicKey generatePublic(KeySpec keySpec)

PrivateKey generatePrivate(KeySpec keySpec)

conversia de la un obiect cheie la o specificatie de cheie

KeySpec getKeySpec(Key key , Class keySpec)

CertificateFactory
crearea obiectelor certificate cu cheie publica si a listelor de revocare certificate (CRL) dintr-o codificarea adecvata
un asemenea obiect pentru X.509 returneaza o instanta a java.security.cert.X509Certificate si un CRL care este instanta a java.security.cert.X509CRL

crearea unui obiect CertificateFactory

static CertificateFactory getInstance(String type)

static CertificateFactory getInstance(String type , String provider)

static CertificateFactory getInstance(String type , Provider provider)

generarea obiectelor certificat

final Certificate generateCertificates(InputStream inStream)

final Collection generateCertificates(InputStream inStream)

generarea obiectelor CRL

final CRL generateCRL(InputStream inStream)

final Collection generateCRL(InputStream inStream)

generarea obiectelor CertPath

final CertPath generateCertPath(InputStream inStream)

final CertPath generateCertPath(InputStream inStream , String encoding)

final CertPath generateCertPath(List certificates)

final Iterator getCertPathEncodings()

KeyStore
generarea si gestionarea unei baze de date a cheilor si stocarea certificatelor; cheile private au asociat un lant de certificare ceea ce autentifica cheile publice
aceasta clasa reprezinta o stocare in memorie a colectiilor de chei si certificate

cheie
este secreta sau privata, stocata in format protejat

certificat de incredere
certificat cu cheie publica

crearea unui obiect KeyStore

static KeyStore getInstance(String type)

static KeyStore getInstance(String type , String provider)

static KeyStore getInstance(String type , Provider provider)

incarcarea in memorie a unui obiect KeyStore
pentru a putea fi utilizat o instanta a acestei clase trebuie incarcata in memorie
final void load( InputStream , char[] password)
parola este optionala si daca este furnizata se va face o verificare de integritate

obtinerea unei liste a alias-uri dintr-un obiect KeyStore
final Enumeration aliases()

determinarea tipurilor intrarilor stocat intr-un obiect KeyStore

final boolean isKeyEntry( String alias)

final boolean isCertificateEntry( String alias)

adaugarea/modificarea si stergerea intrarilor dintr-un obiect KeyStore

adaugare/modificare

certificate
final void setCertificateEntry( String alias , Certificate entry)

chei

final void setKeyEntry( String alias , Key key , char[] password , Certificate[] chain)

final void setKeyEntry( String alias , byte[] key , Certificate[] chain)
array-ul de octeti este in format protejat

stergere
final void deleteEntry(String alias)

obtinerea intrarilor stocate intr-un obiect KeyStore

certificate

final Certificate getCertificate(String alias)

final Certificate[] getCertificate(String alias)

final String getCertificateAlias(Certificate cert)

chei
final Key getKey(String alias , char[] password)

salvarea unui obiect KeyStore
final void store(OutputStream stream , char[] password)

AlgorithmParameters
gestionarea parametrilor unui algoritm
reprezentarea nu este trasnparenta, neobtinandu-se accesul direct la parametri ci numai numele algoritmului asociat multimiii parametrilor si o codificare a acestora

crearea unui obiect AlgorithmParameters

static AlgorithmParameters getInstance( String algorithm)

static AlgorithmParameters getInstance( String algorithm , String provider)

static AlgorithmParameters getInstance( String algorithm , Provider provider)

initializarea unui obiect AlgorithmParameters

void init(AlgorithmParameterSpec paramSpec)

void init(byte[] params)

void init(byte[] params , String format)
params este un array de octeti codificati, format este numele decodificarii (daca lipseste se utilizeaza formatul de decodificare primar care este ASN.1)
obiectul se initializeaza o singura data, nefiind reutilizabil

obtinerea codificarii parametrilor

codificarea in forma primara
byte[] getEncoded()

cu specificarea codificarii
byte[] getEncoded( String format)

furnizorul implicit de servicii criptografice ignora formatul codificarii

obtinerea parametrilor in mod transparent
AlgorithmParameterSpec getParameterSPec(Class paramSpec)

AlgorithmParameterGenerator
generarea unei multimi de parametri pentru un algoritm specificat

crearea unui obiect AlgorithmParameterGenerator

static AlgorithmParameterGenerator getInstance( String algorithm)

static AlgorithmParameterGenerator getInstance( String algorithm , String provider)

static AlgorithmParameterGenerator getInstance( String Provider , String provider)

initializarea unui obiect AlgorithmParameterGenerator

generarea parametrilor
o data creat si initializat obiectul poate genera parametrii
AlgorithmParameters generateParameters()

SecureRandom
generarea de numere pseudoaleatoare

crearea unui obiect SecureRandom

static SecureRandom getInstance( String algorithm)

static SecureRandom getInstance( String algorithm , String provider)

static SecureRandom getInstance( String algorithm , Provider provider)

initializarea cheii de generare

synchronized public void setSeed( byte[] seed)

public void setSeed( long seed)

apelurile repetate conduc la o cheie de generare obtinuta din vechea cheie la care se adauga noua cheie

uzul unui obiect SecureRandom
synchronized public void nextBytes( byte[] bytes)

generarea de chei de generare
byte[] generateSeed ( int numBytes)

CertPathBuilder
construirea de cai de certificare

instantierea clasei CertPathBuilder

static CertPathBuilder getInstance( String algorithm)

static CertPathBuilder getInstance( String algorithm , String provider)

static CertPathBuilder getInstance( String algorithm , Provider provider)

construirea unei cai de certificare
CertPathBuilderResult build (CertPathParameters params)

interogari

furnizor
Provider getProvider()

algoritm
String getAlgoithm()

tip
static String getDefaultType()
returneaza tipul asa cum este specificat in fisierul de configurare de securitate sau "PKIX" altfel

CertPathValidator
validarea lanturilor (cailor) de certificate

creare obiect CertPathValidator

static CertPathValidator getInstance( String algorithm)

static CertPathValidator getInstance( String algorithm , String provider)

static CertPathValidator getInstance( String algorithm , Provider provider)

validarea unei cai de certificare
CertPathValidatorResult validate( CertPath certPath , CertPathParameters params)

interogari

String getAlgorithm()

static String getDefaultType()

Provider getProvider()

CertStore
obtinerea de certificate, care nu sunt de incredere, si CRL-uri (ex: CertStore implementat ca o implementare LDAP); utilizeaza o arhitectura specifica furnizorului de servicii criptografice;

crearea unui obiect

obtinerea unui certificat

obtinerea ueni CRL

interogari

clase si interfete care implementeaza sau extind interfata Key (specificare opaca)
o reprezentare opaca a unei chei se face fara a avea acces la informatia de cheie
o reprezentare transparenta a unei chei permite accesul la informatia de cheie
interfata Key este radacina ierarhiei pentru specificarea opaca a cheilor, definind functionalitatile necesare
caracteristici
algoritmul cheii
String getAlgorithm()

forma codificata
care se foloseste atunci cand este nevoie de reprezentarea standard (ex: X.509, PKCS#8) a cheii in afara JVM
byte[] getEncoded()

formatul
String getFormat()

mod de lucru
obtinerea cheilor din

generatoare de chei

certificate

specificatori de chei (prin KeyFactory)

implementari ale KeyStore

parsingul cheilor codificate, KeyFactory

parsingul certificatelor, CertificateFactory

interfete care extind interfata Key (definita in pachetul java.security.interfaces)
DHPrivateKey

DHPublicKey

DSAPrivateKey

DSAPublicKey

PBEKey

PrivateKey

PublicKey

RSAMultiPrimePrivateCrtKey

RSAPrivateCrtKey

RSAPrivateKey

RSAPublicKey

SecretKey

clase si interfete pentru specificarea parametrilor algoritmilor

interfata AlgorithmParameterSpec
nu contine metode sau constante si are rolul de a grupa specificarile parametrilor

clasa DSAParameterSpec
este o implementare a interfetei AlgorithmParameterSpec ce specifica multimea parametrilor utilizati de algoritmul DSA

clase si interfete pentru specificarea cheii (specificare tansparenta)

interfete
interfata KeySpec nu contine metode sau constante si are rolul de a grupa specificarile parametrilor

clase

DSAPrivateKeySpec

DSAPublicKeySpec

RSAPrivateKeySpec

RSAPrivateCrtKeySpec

RSAMultiPrimePrivateCrtKeySpec

RSAPublicKeySpec

EncodedKeySpec
: este interfata catre furnizorul de servicii criptografice
realizeaza inregistrarea serviciilor criptografice si poate fi folosita pentru a inregistra servicii de securitate
la crearea unei instante pentru o clasa motor se poate specifica optional furnizorul de servicii criptografice; daca nu se specifica, metoda getInstance cauta furnizorii care implementeaza serviciul criptografic cerut asociat cu numele algoritmului; Orice JVM are o lista de preferinte pentru aceasta cautare
instalarea unui furnizor de servicii criptografice
instalarea
inserarea in "classpath" a cai unde se afla jar-ul sau zip-ul

configurarea
se insereaza in fisierul java.security o linie "security.provider.n = masterClassName"

metode
public String getName()

public double getVersion()

public String getInfo()
: contine metode statice, nu se instantiaza si gestioneaza furnizorii de servicii criptografice si setarile generale de securitate care pot fi apelate numai in programe de incredere
un program de incredere este:

o aplicatie locala care ruleaza sub un gestionar de securitate

un applet sau o aplicatie care are drepturi de rulare a acestor metode

codul rulat are o sursa care poate fi URL-ul dar poate fi o referinta catre cheia publica corespunzatoare cheii private utilizate pentru semnarea codului; cheile publice sunt referite prin aliasuri din magazia de stocare
intr-un fisier de configurare a politicii, codul sursa este reprezentat prin URL si alias
ex:
grant codeBase "...", signedBy "..." (
permission java.security.SecurityPermisssion "insertProvider.";

permission java.security.SecurityPermisssion "removeProvider.";

permission java.security.SecurityPermisssion "putProviderProperty.";
};

metode
gestionarea furnizorilor

functie nume metoda obs.

interogare static Provider[] getProvider() ordinea in vector este data de ordinea de preferinta a furnizorilor

interogare static Provider getProvider(Stirng providerName)

adaugare static int addProvider(Provider provider) adauga la sfarsitul listei si returneaza ordine de preferinta sau -1 daca furnizorul exista deja

adaugare insertProviderAt(Provider provider , int position) insereaza in lista la pozitia "position", aluneca in jos restul listei si returneaza ordinea de preferinta

stergere static void removeProvider(String name) dupa stergerea furnizorului componentele listei sunt alunecate in fata cu o pozitie

proprietati de securitate

static String getProperty(String key)

static String setProperty(String key , String datum)
MessageDigest: calcularea unei valori de hash

crearea unui obiect MessageDigest

static MessageDigest getInstance(String algorithm)

static MessageDigest getInstance(String algorithm , String provider)

static MessageDigest getInstance(String algorithm , Provider provider)

incarcarea mesajului in obiectul creat

void update(byte input)

void update(byte[] input)

void update(byte[] input , int offset , int len)

calcularea valorii de hash

byte[] digest()

byte[] digest(byte[] input)

byte[] digest(byte[] input , int offset , int len)
Signature: semnarea si verificarea digitala
un obiect Signature este modal (este intotdeauna intr-o stare data si poate face o singura operatie)
starile unui obiect Signature
UNINITIALIZED - starea imediat la crearea obiectului

SIGN - obiect pentru semnare

VERIFY - obiect pentru verificare verificare

crearea unui obiect Signature

static Signature getInstance(String algorithm)

static Signature getInstance(String algorithm , String provider)

static Signature getInstance(String algorithm , Provider provider)

initializarea unui obiect Signature

final void initSign(PrivateKey privateKey) - obiectul este pus in starea SIGN

final void initVerify(PublicKey publicKey) - obiectul este pus in starea VERIFY

final void initVerify(Certificate certificate) - obiectul este pus in starea VERIFY
acelasi obiect poate fi folosit si la semnare si la verificare

semnarea
incarcarea cu date
final void update(byte b)

final void update(byte[] data)

final void update(byte[] data , int off , int len)

generarea semnaturii
final byte[] sign()

final int sign(byte[] outbuf , int offset , int len)

verificarea
incarcarea cu date
final void update(byte b)

final void update(byte[] data)

final void update(byte[] data , int off , int len)
dupa apel obiectul ajunge in starea SIGN

generarea semnaturii
final boolean verify(byte[] signature)

final boolean verify(byte[] signature , int offset , int length)
dupa apel obiectul ajunge in starea VERIFY
KeyPairGenerator: generarea unei perechi de chei publica/privata

crearea unui obiect KeyPairGenerator

static KeyPairGenerator getInstance(String algorithm)

static KeyPairGenerator getInstance(String algorithm , String provider)

static KeyPairGenerator getInstance(String algorithm , Provider provider)

initializarea unui obiect KeyPairGenerator

independent de algoritm

void initialize(int keysize , SecureRandom random)

void initialize(int keysize)
este la latitudinea furnizorului ceea ce se intampla cu parametrii specifici algoritmului

specific unui algoritm

void initialize (AlgorithmParameterSpec params , SecureRandom random)

void initialize (AlgorithmParameterSpec params)

generarea unei perechi de chei
KeyPair generateKeyPair()
KeyFactory: conversia intre tipul criptografic Key si specificatiile de cheie care sunt reprezentari transparente ale informatiile de cheie
un asemenea obiect poate fi utilizat la conversia intre specificatii compatibile de chei

crearea unui obiect KeyFactory

static KeyFactory getInstance(String algorithm)

static KeyFactory getInstance(String algorithm , String provider)

static KeyFactory getInstance(String algorithm , Provider provider)

conversia de la o specificatie de cheie la un obiect cheie

PublicKey generatePublic(KeySpec keySpec)

PrivateKey generatePrivate(KeySpec keySpec)

conversia de la un obiect cheie la o specificatie de cheie

KeySpec getKeySpec(Key key , Class keySpec)
CertificateFactory: crearea obiectelor certificate cu cheie publica si a listelor de revocare certificate (CRL) dintr-o codificarea adecvata
un asemenea obiect pentru X.509 returneaza o instanta a java.security.cert.X509Certificate si un CRL care este instanta a java.security.cert.X509CRL

crearea unui obiect CertificateFactory

static CertificateFactory getInstance(String type)

static CertificateFactory getInstance(String type , String provider)

static CertificateFactory getInstance(String type , Provider provider)

generarea obiectelor certificat

final Certificate generateCertificates(InputStream inStream)

final Collection generateCertificates(InputStream inStream)

generarea obiectelor CRL

final CRL generateCRL(InputStream inStream)

final Collection generateCRL(InputStream inStream)

generarea obiectelor CertPath

final CertPath generateCertPath(InputStream inStream)

final CertPath generateCertPath(InputStream inStream , String encoding)

final CertPath generateCertPath(List certificates)

final Iterator getCertPathEncodings()
KeyStore: generarea si gestionarea unei baze de date a cheilor si stocarea certificatelor; cheile private au asociat un lant de certificare ceea ce autentifica cheile publice
aceasta clasa reprezinta o stocare in memorie a colectiilor de chei si certificate

cheie
este secreta sau privata, stocata in format protejat

certificat de incredere
certificat cu cheie publica

crearea unui obiect KeyStore

static KeyStore getInstance(String type)

static KeyStore getInstance(String type , String provider)

static KeyStore getInstance(String type , Provider provider)

incarcarea in memorie a unui obiect KeyStore
pentru a putea fi utilizat o instanta a acestei clase trebuie incarcata in memorie
final void load( InputStream , char[] password)
parola este optionala si daca este furnizata se va face o verificare de integritate

obtinerea unei liste a alias-uri dintr-un obiect KeyStore
final Enumeration aliases()

determinarea tipurilor intrarilor stocat intr-un obiect KeyStore

final boolean isKeyEntry( String alias)

final boolean isCertificateEntry( String alias)

adaugarea/modificarea si stergerea intrarilor dintr-un obiect KeyStore

adaugare/modificare

certificate
final void setCertificateEntry( String alias , Certificate entry)

chei

final void setKeyEntry( String alias , Key key , char[] password , Certificate[] chain)

final void setKeyEntry( String alias , byte[] key , Certificate[] chain)
array-ul de octeti este in format protejat

stergere
final void deleteEntry(String alias)

obtinerea intrarilor stocate intr-un obiect KeyStore

certificate

final Certificate getCertificate(String alias)

final Certificate[] getCertificate(String alias)

final String getCertificateAlias(Certificate cert)

chei
final Key getKey(String alias , char[] password)

salvarea unui obiect KeyStore
final void store(OutputStream stream , char[] password)
AlgorithmParameters: gestionarea parametrilor unui algoritm
reprezentarea nu este trasnparenta, neobtinandu-se accesul direct la parametri ci numai numele algoritmului asociat multimiii parametrilor si o codificare a acestora

crearea unui obiect AlgorithmParameters

static AlgorithmParameters getInstance( String algorithm)

static AlgorithmParameters getInstance( String algorithm , String provider)

static AlgorithmParameters getInstance( String algorithm , Provider provider)

initializarea unui obiect AlgorithmParameters

void init(AlgorithmParameterSpec paramSpec)

void init(byte[] params)

void init(byte[] params , String format)
params este un array de octeti codificati, format este numele decodificarii (daca lipseste se utilizeaza formatul de decodificare primar care este ASN.1)
obiectul se initializeaza o singura data, nefiind reutilizabil

obtinerea codificarii parametrilor

codificarea in forma primara
byte[] getEncoded()

cu specificarea codificarii
byte[] getEncoded( String format)

furnizorul implicit de servicii criptografice ignora formatul codificarii

obtinerea parametrilor in mod transparent
AlgorithmParameterSpec getParameterSPec(Class paramSpec)
AlgorithmParameterGenerator: generarea unei multimi de parametri pentru un algoritm specificat

crearea unui obiect AlgorithmParameterGenerator

static AlgorithmParameterGenerator getInstance( String algorithm)

static AlgorithmParameterGenerator getInstance( String algorithm , String provider)

static AlgorithmParameterGenerator getInstance( String Provider , String provider)

initializarea unui obiect AlgorithmParameterGenerator

generarea parametrilor
o data creat si initializat obiectul poate genera parametrii
AlgorithmParameters generateParameters()
SecureRandom: generarea de numere pseudoaleatoare

crearea unui obiect SecureRandom

static SecureRandom getInstance( String algorithm)

static SecureRandom getInstance( String algorithm , String provider)

static SecureRandom getInstance( String algorithm , Provider provider)

initializarea cheii de generare

synchronized public void setSeed( byte[] seed)

public void setSeed( long seed)

apelurile repetate conduc la o cheie de generare obtinuta din vechea cheie la care se adauga noua cheie

uzul unui obiect SecureRandom
synchronized public void nextBytes( byte[] bytes)

generarea de chei de generare
byte[] generateSeed ( int numBytes)
CertPathBuilder: construirea de cai de certificare

instantierea clasei CertPathBuilder

static CertPathBuilder getInstance( String algorithm)

static CertPathBuilder getInstance( String algorithm , String provider)

static CertPathBuilder getInstance( String algorithm , Provider provider)

construirea unei cai de certificare
CertPathBuilderResult build (CertPathParameters params)

interogari

furnizor
Provider getProvider()

algoritm
String getAlgoithm()

tip
static String getDefaultType()
returneaza tipul asa cum este specificat in fisierul de configurare de securitate sau "PKIX" altfel
CertPathValidator: validarea lanturilor (cailor) de certificate

creare obiect CertPathValidator

static CertPathValidator getInstance( String algorithm)

static CertPathValidator getInstance( String algorithm , String provider)

static CertPathValidator getInstance( String algorithm , Provider provider)

validarea unei cai de certificare
CertPathValidatorResult validate( CertPath certPath , CertPathParameters params)

interogari

String getAlgorithm()

static String getDefaultType()

Provider getProvider()
CertStore: obtinerea de certificate, care nu sunt de incredere, si CRL-uri (ex: CertStore implementat ca o implementare LDAP); utilizeaza o arhitectura specifica furnizorului de servicii criptografice;

crearea unui obiect

obtinerea unui certificat

obtinerea ueni CRL

interogari
clase si interfete care implementeaza sau extind interfata Key (specificare opaca): o reprezentare opaca a unei chei se face fara a avea acces la informatia de cheie
o reprezentare transparenta a unei chei permite accesul la informatia de cheie
interfata Key este radacina ierarhiei pentru specificarea opaca a cheilor, definind functionalitatile necesare
caracteristici
algoritmul cheii
String getAlgorithm()

forma codificata
care se foloseste atunci cand este nevoie de reprezentarea standard (ex: X.509, PKCS#8) a cheii in afara JVM
byte[] getEncoded()

formatul
String getFormat()

mod de lucru
obtinerea cheilor din

generatoare de chei

certificate

specificatori de chei (prin KeyFactory)

implementari ale KeyStore

parsingul cheilor codificate, KeyFactory

parsingul certificatelor, CertificateFactory

interfete care extind interfata Key (definita in pachetul java.security.interfaces)
DHPrivateKey

DHPublicKey

DSAPrivateKey

DSAPublicKey

PBEKey

PrivateKey

PublicKey

RSAMultiPrimePrivateCrtKey

RSAPrivateCrtKey

RSAPrivateKey

RSAPublicKey

SecretKey
clase si interfete pentru specificarea parametrilor algoritmilor: interfata AlgorithmParameterSpec
nu contine metode sau constante si are rolul de a grupa specificarile parametrilor

clasa DSAParameterSpec
este o implementare a interfetei AlgorithmParameterSpec ce specifica multimea parametrilor utilizati de algoritmul DSA
clase si interfete pentru specificarea cheii (specificare tansparenta): interfete
interfata KeySpec nu contine metode sau constante si are rolul de a grupa specificarile parametrilor

clase

DSAPrivateKeySpec

DSAPublicKeySpec

RSAPrivateKeySpec

RSAPrivateCrtKeySpec

RSAMultiPrimePrivateCrtKeySpec

RSAPublicKeySpec

EncodedKeySpec

Tehnici de gestionare a cheilor

2006-01-20T16:22:00.000+02:00

cadru de lucru: context
Gestionarea cheilor are loc in contextul politicii de securitate care defineste in mod implicit/explicit amenintarile la care trebuie sa faca fata un sistem si de aici cerintele criptografice.
Politica de securitate defineste

proceduri privitoare la aspectele tehnnice si administrative ale gestionarii cheilor

responsabilitatile partilor

tipurile de inregistrari care sa permita rapoarte ulterioare unui eveniment de securitate

obiectiv
pastrarea in siguranta a informatiilor referitoare la chei ai sa fie contracarate amenintari cum ar fi:

compromiterea confidentialitatii cheilor secrete

compromiterea autenticitatii cheilor secrete sau publice

utilizarea neautorizata a cheilor publice sau secrete

modele de distributie a cheilor

problema distributiei cheilor
intr-un sistem cu chei simetrice cu n utilizatori, daca fiecare pereche de utilizatori partajeaza o cheie secreta distincta, numarul de chei este n ( n - 1 ) / 2, ceea ce pentru n mare conduce la un numar de chei inacceptabil de mare si de aici necesitatea unui server central

mecanisme

punct la punct
A si B partajeaza a priori o cheie secreta

cu terta parte
A si B partajeaza fiecare o cheie secreta cu serverul

centru de distributie a cheilor (KDC)
KDC distirbuie chei utilizatorilor care partajeaza secrete cu acesta

centru de translatie a cheilor (KTC)
functioneaza ca un KDC dar cheia de sesiune este generata de una dintre parti

cheile partajate sunt distribuite prin tehnici necriptografice si garanteaza autenticitatea partilor

functii ale tertului, T

clasificare dupa criteriul interactiunii in timp real

in-line
T este un intermediar ce are rolulu de mijloc de comunicatie intre A si B

on-line
T este implicat in fiecare sesiune, comunicand cu o parte sau cu ambele, dar A si B comunica direct intre ei

off-line
T nu este implicat in protocol in timp real dar pregateste a priori informatii care sunt disponibile lui A si/sau B care sunt utilizate in protocol

clasificare pentru tert intr-un sistem de certificate cu cheie publica

autoritate de certificare (CA)
responsabila pentru distributia cheilor publice carora le garanteaza autenticitatea
in sistemele bazate pe certificate, cheile publice sunt legate de nume prin certificate semnate; autoritatea gestioneaza numerele certificatelor si revocarea acestora

server de nume
gestioneaza spatiul de nume

autoritate de inregistrare
autorizeaza entitatile, care sunt identificate prin nume unice, ca membri ai domeniului de securitate

generator de chei
creeaza perechi de chei publice/private
poate fi parte a entitatii, a CA sau un sistem de infcredere independent

director de certificate
gestionar al unei baze de date cu certificate ce este gestionata de CA sau de catre entitati

functii primare

server de autentificare
realizeaza distributia cheilor intre entitati, inclusiv autentificarea acestora

gestionar de chei
realizeaza stocarea cheilor, informatiilor de auditare, aplicarea cerintelor de ciclu de viata a cheilor

alte functii

agent de marcare timp
valideaza existenta unui document la un moment de timp sua lipirea unei date calendaristice la o tranzactie sau mesaj digital

notar
verifica o semnatura digitala la un moment dat de timp sau mai general, atesta o depozitie data intr-o anumita jurisdictie la un moment dat de timp

comparatie intre tehnicile, cu cheie publica si cele cu cheie simetrica, de gestionare a cheilor

avantaje ale tehnicilor cu cheie publica
gestionare simplificata a cheilor

nu este necesar un server de incredere on-line

functiuni suplimentare
context: Gestionarea cheilor are loc in contextul politicii de securitate care defineste in mod implicit/explicit amenintarile la care trebuie sa faca fata un sistem si de aici cerintele criptografice.
Politica de securitate defineste

proceduri privitoare la aspectele tehnnice si administrative ale gestionarii cheilor

responsabilitatile partilor

tipurile de inregistrari care sa permita rapoarte ulterioare unui eveniment de securitate
obiectiv: pastrarea in siguranta a informatiilor referitoare la chei ai sa fie contracarate amenintari cum ar fi:

compromiterea confidentialitatii cheilor secrete

compromiterea autenticitatii cheilor secrete sau publice

utilizarea neautorizata a cheilor publice sau secrete
modele de distributie a cheilor: problema distributiei cheilor
intr-un sistem cu chei simetrice cu n utilizatori, daca fiecare pereche de utilizatori partajeaza o cheie secreta distincta, numarul de chei este n ( n - 1 ) / 2, ceea ce pentru n mare conduce la un numar de chei inacceptabil de mare si de aici necesitatea unui server central

mecanisme

punct la punct
A si B partajeaza a priori o cheie secreta

cu terta parte
A si B partajeaza fiecare o cheie secreta cu serverul

centru de distributie a cheilor (KDC)
KDC distirbuie chei utilizatorilor care partajeaza secrete cu acesta

centru de translatie a cheilor (KTC)
functioneaza ca un KDC dar cheia de sesiune este generata de una dintre parti

cheile partajate sunt distribuite prin tehnici necriptografice si garanteaza autenticitatea partilor
functii ale tertului, T: clasificare dupa criteriul interactiunii in timp real

in-line
T este un intermediar ce are rolulu de mijloc de comunicatie intre A si B

on-line
T este implicat in fiecare sesiune, comunicand cu o parte sau cu ambele, dar A si B comunica direct intre ei

off-line
T nu este implicat in protocol in timp real dar pregateste a priori informatii care sunt disponibile lui A si/sau B care sunt utilizate in protocol

clasificare pentru tert intr-un sistem de certificate cu cheie publica

autoritate de certificare (CA)
responsabila pentru distributia cheilor publice carora le garanteaza autenticitatea
in sistemele bazate pe certificate, cheile publice sunt legate de nume prin certificate semnate; autoritatea gestioneaza numerele certificatelor si revocarea acestora

server de nume
gestioneaza spatiul de nume

autoritate de inregistrare
autorizeaza entitatile, care sunt identificate prin nume unice, ca membri ai domeniului de securitate

generator de chei
creeaza perechi de chei publice/private
poate fi parte a entitatii, a CA sau un sistem de infcredere independent

director de certificate
gestionar al unei baze de date cu certificate ce este gestionata de CA sau de catre entitati

functii primare

server de autentificare
realizeaza distributia cheilor intre entitati, inclusiv autentificarea acestora

gestionar de chei
realizeaza stocarea cheilor, informatiilor de auditare, aplicarea cerintelor de ciclu de viata a cheilor

alte functii

agent de marcare timp
valideaza existenta unui document la un moment de timp sua lipirea unei date calendaristice la o tranzactie sau mesaj digital

notar
verifica o semnatura digitala la un moment dat de timp sau mai general, atesta o depozitie data intr-o anumita jurisdictie la un moment dat de timp
comparatie intre tehnicile, cu cheie publica si cele cu cheie simetrica, de gestionare a cheilor: avantaje ale tehnicilor cu cheie publica
gestionare simplificata a cheilor

nu este necesar un server de incredere on-line

functiuni suplimentare
tehnici pentru distribuirea cheilor private si a cheilor secrete: clasificarea cheilor dupa modul de utilizare

chei sablon
chei neprotejate criptografic ce sunt distribuite manual sau instalate initial si sunt protejate prin proceduri de control si/sau izolare fizica

chei de criptare a cheilor
sunt chei simterice sau publice ce sunt folosite in protocoalele de transport ale cheilor; pot fi protejate prin alte chei

chei de date
sunt utilizate in operatiile criptografice asupra datelor utilizatorului; in general sunt chei simetrice

criptoperioada unei chei
este intervalul de timp in care o cheie este valida pentru folosire de catre partile indreptatite

clasificarea cheilor dupa criteriul temporalitatii

chei pe termne lung
cheile sablon, deseori cheile de criptare a cheilor, cheile utilizate pentru acordul asupra cheilor

chei pe termen scurt
cheile ce sunt stabilitate prin transport sau acord si deseori cheile de date sau cheile de sesiune
in general comunicatia se face cu chei de termen scurt in timp ce stocarea se face utilizand chei de termen lung

KTC si certificate cu cheie simetrica

protocol translatie mesaj prin KTC

A interactioneaza cu KTC si cu B

A transfera un mesaj secret, M sau o cheie de sesiune B

E este un algoritm de criptare simetrica

setare initiala: A si T partajeaza cheia K_AT, B si T partajeaza cheia K_BT

mesaje

A → T: A, E_{K_AT}(B, M)

A ← T: A, E_{K_BT}(B, M)

A → B: A, E_{K_BT}(B, M)

actiuni

A cripteaza M sub K_AT si trimite lui T impreuna cu identificatorul propriu

T decripteaza M, determina destinatarul, cripteaza M cu cheia destinataruluiu

T trimite lui A mesajul pe care acesta il va trimite lui B; T poate trimite direct lui B

certificate cu cheie simetrica
pot constitui un mijloc prin care KTC evita necesitatea unei baze de date sigure cu secretele utilizatorilor
cheia fiecarui utilizator este ambalata intr-un certificat, E_{K_T}(K_BT , B), criptat cu o cheie sablon simetrica, K_T, cunoscuta doar lui T astfel ca stocarea sigura este necesaraa doar pentru aceasta cheie
tehnici pentru distribuirea cheilor publice: obtinerea cheilor publice

livrarea punct la punct pe un canal de incredere
cheile sunt obtinute direct de la alti utilizatori

accesul direct la un fisier public de incredere
cheile sunt obtinute dintr-o baza de date publica a carei integritate este de incredere; o metoda poate fi autentificarea fisierului public prin autententificarea arborescenta a cheilor publice

utilizarea unui server on-line de incredere
ce asigura accesul la echivalentul unui fisier public ce contine cheile publice autentice; transmisiile cheilor sunt semnate

utilizarea unui server off-line si acertificatelor
entitatea A contacteaza CA pentru a-si inregistra cheia publica si obtine semnatura de verificare; CA certifica cheia publica a lui A legand-o de un sir care-l identifica pe A; partile obtin cheile publice autentice prin schimbarea certificatelor sau direct dintr-un director public

utilizarea unor sisteme care garanteaza implicit autenticitatea parametrilor publici
utilizarea unor algoritmi ce permit ca o modificare a parametrilor publici sa conduca la un insucces, detectabil si necompromitatoar, al tehnicilor criptografice
aceste sisteme includ sistemele bazate pe identitate

certificate cu cheie publica

certificat cu cheie publica
o structura de date ce compusa dintr-o parte de date si o parte de semnatura; partea de date contine text in clar, cel putin o cheie publica si un sir de identificare a entitatii. Partea de semnatura contine semnatura digitala, emisa de CA, asupra partii de date.
sirul de identificare a entitatii trebuie sa fie un nume unic in sistem pe care CA il asociaza ueni entiati reale
CA poseda propria pereche semnatura-cheie, ce poate fi facuta disponibila prin mijloace necriptografice

crearea certificateleor

tertul creeaza perechea de chei
, include identitatea entitaii si cheia publica intr-un certificat; entitatea obtine cheia privata pe un canal sigur (autentic si privat)

entitatea isi creeaza prorpia pereche de chei
si transfera cheia publica tertului pe un canal sigur

utilizarea si verificarea certificatelor
entitatea B utilizeaza un certificat pentru a obtine cheia publica autentica a lui A
(o singura data) obtine cheia publica autentica a CA

obtine un sir care identifica in mod unic entitatea A

obtine un certificat cu cheie publica care corespunde entiatii A si care este in acord cu sirul de identificare

verifica perioada de validitate a certificatului folosind data si ora curente obtinute de la un ceas de incredere

verifica validitatea cheii publice a CA

verifica semnatura din certificatul lui A folosind cheia publica a CA

verifica daca certificatul nu a fost revocat

daca toate verificarile au succes accepta cheia publica din certificat ca fiind cheia autentica a lui A

certificate de atribute
sunt similare certificatelor cu chei publice dar au rolul de a permite specificarea altor informatii decat cheile publice

sisteme bazate pe identitate

sistem criptografic bazat pe identitate
Sistem asimetric in care informatia publica de identificare a unei entitati joaca rolul cheii publice si este utilizata de catre tert pentru a calcula cheia privata

autentificarea in sisteme bazate pe identitate
Motivatia este de a crea un sistem criptografic care modeleaza un sistem de posta ideal in care numele unei persoane este suficient pentru a trimite mesaje care pot fi citite doar de catre destinatar si care sa permita verificarea unei semnaturi pe care numai aceea persoana o poate emite. In asemenea sisteme:

utilizatori nu schmiba chei

nu sunt necesare directoare publice

serviciile unui tert sunt necesare doar in faza initiala

chei publice certificate implicit

caracteristici

cheile publice ale entitatilor pot fi reconstruite din informatii publice, care astfel inlocuiesc certificate;e

informatia publica include

informatii publice asociate tertului

identitatea entitatii (nume, adresa, etc.)

informatii publice suplimentare despre entitate

integritatea unei chei publice reconstruite nu este verificabila direct dar o cheie publica poate fi reconstruita doar din informatiile autentice despre o entitate
certificate cu cheie publica: certificat cu cheie publica
o structura de date ce compusa dintr-o parte de date si o parte de semnatura; partea de date contine text in clar, cel putin o cheie publica si un sir de identificare a entitatii. Partea de semnatura contine semnatura digitala, emisa de CA, asupra partii de date.
sirul de identificare a entitatii trebuie sa fie un nume unic in sistem pe care CA il asociaza ueni entiati reale
CA poseda propria pereche semnatura-cheie, ce poate fi facuta disponibila prin mijloace necriptografice

crearea certificateleor

tertul creeaza perechea de chei
, include identitatea entitaii si cheia publica intr-un certificat; entitatea obtine cheia privata pe un canal sigur (autentic si privat)

entitatea isi creeaza prorpia pereche de chei
si transfera cheia publica tertului pe un canal sigur

utilizarea si verificarea certificatelor
entitatea B utilizeaza un certificat pentru a obtine cheia publica autentica a lui A
(o singura data) obtine cheia publica autentica a CA

obtine un sir care identifica in mod unic entitatea A

obtine un certificat cu cheie publica care corespunde entiatii A si care este in acord cu sirul de identificare

verifica perioada de validitate a certificatului folosind data si ora curente obtinute de la un ceas de incredere

verifica validitatea cheii publice a CA

verifica semnatura din certificatul lui A folosind cheia publica a CA

verifica daca certificatul nu a fost revocat

daca toate verificarile au succes accepta cheia publica din certificat ca fiind cheia autentica a lui A

certificate de atribute
sunt similare certificatelor cu chei publice dar au rolul de a permite specificarea altor informatii decat cheile publice
certificat cu cheie publica: o structura de date ce compusa dintr-o parte de date si o parte de semnatura; partea de date contine text in clar, cel putin o cheie publica si un sir de identificare a entitatii. Partea de semnatura contine semnatura digitala, emisa de CA, asupra partii de date.
sirul de identificare a entitatii trebuie sa fie un nume unic in sistem pe care CA il asociaza ueni entiati reale
CA poseda propria pereche semnatura-cheie, ce poate fi facuta disponibila prin mijloace necriptografice

crearea certificateleor

tertul creeaza perechea de chei
, include identitatea entitaii si cheia publica intr-un certificat; entitatea obtine cheia privata pe un canal sigur (autentic si privat)

entitatea isi creeaza prorpia pereche de chei
si transfera cheia publica tertului pe un canal sigur

utilizarea si verificarea certificatelor
entitatea B utilizeaza un certificat pentru a obtine cheia publica autentica a lui A
(o singura data) obtine cheia publica autentica a CA

obtine un sir care identifica in mod unic entitatea A

obtine un certificat cu cheie publica care corespunde entiatii A si care este in acord cu sirul de identificare

verifica perioada de validitate a certificatului folosind data si ora curente obtinute de la un ceas de incredere

verifica validitatea cheii publice a CA

verifica semnatura din certificatul lui A folosind cheia publica a CA

verifica daca certificatul nu a fost revocat

daca toate verificarile au succes accepta cheia publica din certificat ca fiind cheia autentica a lui A

certificate de atribute
sunt similare certificatelor cu chei publice dar au rolul de a permite specificarea altor informatii decat cheile publice
sisteme bazate pe identitate: sistem criptografic bazat pe identitate
Sistem asimetric in care informatia publica de identificare a unei entitati joaca rolul cheii publice si este utilizata de catre tert pentru a calcula cheia privata

autentificarea in sisteme bazate pe identitate
Motivatia este de a crea un sistem criptografic care modeleaza un sistem de posta ideal in care numele unei persoane este suficient pentru a trimite mesaje care pot fi citite doar de catre destinatar si care sa permita verificarea unei semnaturi pe care numai aceea persoana o poate emite. In asemenea sisteme:

utilizatori nu schmiba chei

nu sunt necesare directoare publice

serviciile unui tert sunt necesare doar in faza initiala
sistem criptografic bazat pe identitate: Sistem asimetric in care informatia publica de identificare a unei entitati joaca rolul cheii publice si este utilizata de catre tert pentru a calcula cheia privata
autentificarea in sisteme bazate pe identitate: Motivatia este de a crea un sistem criptografic care modeleaza un sistem de posta ideal in care numele unei persoane este suficient pentru a trimite mesaje care pot fi citite doar de catre destinatar si care sa permita verificarea unei semnaturi pe care numai aceea persoana o poate emite. In asemenea sisteme:

utilizatori nu schmiba chei

nu sunt necesare directoare publice

serviciile unui tert sunt necesare doar in faza initiala
chei publice certificate implicit: caracteristici

cheile publice ale entitatilor pot fi reconstruite din informatii publice, care astfel inlocuiesc certificate;e

informatia publica include

informatii publice asociate tertului

identitatea entitatii (nume, adresa, etc.)

informatii publice suplimentare despre entitate

integritatea unei chei publice reconstruite nu este verificabila direct dar o cheie publica poate fi reconstruita doar din informatiile autentice despre o entitate
tehnici pentru controlul utilizarii cheilor: separarea cheilor

Informatia care s-ar putea asocia cheilor:
proprietarul cheii

perioada de validitate

identificatorul cheii (referinte noncriptografice)

utilizarea destinata

algoritmul

numele entitatilor asociate generarii cheii, inregistrarii si certificarii

suma de control a cheii

Principiul separarii cheilor: cheile utilizate in scopuri diferite trebuie sa fie separate criptografic

tehnici pentru controlul utilizarii cheilor simetrice

marcaje de chei si variante de chei
Marcajele de cheie asigura o metoda simpla pentru specificarea utilizarilor permise ale cheilor
Marcajul de cheie este un vector de biti sau un camp structurat care acompaniaza cheia pe intreaga sa durata de viata, fiind criptat impreuna cu aceasta
Tehnici de separare
derivarea unor chei variante dntr-o cheie de baza utilizand parametri si o functie care nu sunt secrete

compensarea cheii: o cheie de criptare K este modificata ca o functie de un contor care se incrementeaza la fiecare utilizare

notarizarea cheilor
este un mecanism pentru distribuirea cheiolor autentificate
este o tehnica destinata prtevenirii substitutiei cheii prin specificarea explicita a identitatilor entitatilor implicate
o cheie este autentificata in functie de identitatile partilor, prin modificarea unei chei de criptareai ai recuperarea cheii protejate se poate face doar specificand corect identitatile; cheia este sigilata cu aceste identitati
notarizarea simpla a cheii: un server de incredere (notar) sau una dintre parti cripteaza cheia de sesiune, S, utilizand cheia de criptare, K, E_{K ⊕ ( A || B)}; cheia de sesiune S este destinata uzului entitatilor A si B; entitatea care doreste sa recupereze S trebuie sa partajeze K si sa specifice A si B in ordinea corecta

vectori de control
este o metoda pentru controlul utilizarii cheilor ce combina marcajele de cheie cu mecanismul de notarizare
fiecarei chei S ii este asociat un vector de control C, un camp de date, ce defineste utilizarile autorizate ale cheii; criptarea este E_{K ⊕ C}(S)
decriptarea necesita specificarea corecta a vectorului de control C si cheii de criptare, K
separarea cheilor: Informatia care s-ar putea asocia cheilor:
proprietarul cheii

perioada de validitate

identificatorul cheii (referinte noncriptografice)

utilizarea destinata

algoritmul

numele entitatilor asociate generarii cheii, inregistrarii si certificarii

suma de control a cheii

Principiul separarii cheilor: cheile utilizate in scopuri diferite trebuie sa fie separate criptografic
tehnici pentru controlul utilizarii cheilor simetrice: marcaje de chei si variante de chei
Marcajele de cheie asigura o metoda simpla pentru specificarea utilizarilor permise ale cheilor
Marcajul de cheie este un vector de biti sau un camp structurat care acompaniaza cheia pe intreaga sa durata de viata, fiind criptat impreuna cu aceasta
Tehnici de separare
derivarea unor chei variante dntr-o cheie de baza utilizand parametri si o functie care nu sunt secrete

compensarea cheii: o cheie de criptare K este modificata ca o functie de un contor care se incrementeaza la fiecare utilizare

notarizarea cheilor
este un mecanism pentru distribuirea cheiolor autentificate
este o tehnica destinata prtevenirii substitutiei cheii prin specificarea explicita a identitatilor entitatilor implicate
o cheie este autentificata in functie de identitatile partilor, prin modificarea unei chei de criptareai ai recuperarea cheii protejate se poate face doar specificand corect identitatile; cheia este sigilata cu aceste identitati
notarizarea simpla a cheii: un server de incredere (notar) sau una dintre parti cripteaza cheia de sesiune, S, utilizand cheia de criptare, K, E_{K ⊕ ( A || B)}; cheia de sesiune S este destinata uzului entitatilor A si B; entitatea care doreste sa recupereze S trebuie sa partajeze K si sa specifice A si B in ordinea corecta

vectori de control
este o metoda pentru controlul utilizarii cheilor ce combina marcajele de cheie cu mecanismul de notarizare
fiecarei chei S ii este asociat un vector de control C, un camp de date, ce defineste utilizarile autorizate ale cheii; criptarea este E_{K ⊕ C}(S)
decriptarea necesita specificarea corecta a vectorului de control C si cheii de criptare, K
gestionarea cheilor intre domenii: domeniu de securitate
Un sistem care este sub controlul unei singure autoritati si in care entitatile din domeniu au incredere
fiecare entitate

partajeaza un secret sau o parola - in cazul simetric

detine cheia publica autentica a CA- in cazul asimetric

ceea ce permite comunicatia pe un canal sigur cu autoritatea sau cu o alta entitate

increderea intre doua domenii

entitatile A si B apartinand domeniilor D_A si D_B ce au autoritatile T_A si T_B doresc sa comunice; A si B fie

partajeaza o cheie simetrica

partajeaza chei publice de incredere

ambele fiind posibile daca T_A si T_B au o relatie de incredere
A si B delega pe T_A si T_B prin intermediul canalelor sigure (A , T_A) , (T_A , T_B ) , ( B , T_B ) in stabilirea relatiei de incredere ( A , B)
daca T_A si T_B nu au o relatie de incredre directa, vor face apel la T_C in care au ambiele incredere

metode

cheie simetrica de incredere

A cere lui T_A sa obtina o cheie pe care sa o partajeze cu B

T_A si T_B stabilesc o cheie de termen scurt K_AB

T_A si T_B distribuie K_AB lui A si B

A comunica direct cu B utilizand K_AB

cheie publica de incredere

A cere lui T_A cheia publica a lui B

T_A o obtine de la T_B care garanteaza autenticitatea

T_A transfera aceasta cheie lui A

A comunica direct cu B utilizand K_AB

certificat incrucisat
un certificat creat de CA₁ prin care se certifica cheia publica a CA₂

modele de incredere cu mai multe CA-uri
Relatiile de incredere intre CA-uri, in sisteme cu cheie publica, pot fi organizate in mai multe moduri

lanturi de certificate si cai de certificare
o entitate doreste sa obtina o cheie publica autentica, verificand un certicat emis de o alta CA decat CA in care are incredere
calea de certificare este un drum in graful ce contine CA-urile, pentru care nodul initial este CA-ul in care entitatea are incredere si cel final este CA-ul care a emis certificatul pe care entitatea doreste sa-l verificae
un lant de certificate este secventa de certificate emise de CA-urile dintr-o cale de certificare

domenii separate
CA-urile trebuie sa aiba relatii de incredere pentru ca o entitate dintr-un domeniu sa poata comunica criptografic cu o entitate din alt domeniu; implicit CA-urile definesc separate de securitate care nu au relatii de incredere ai entitatile dintr-un domeniu nu pot verifica autenticitatea certificatelor emise in alt domeniu
CA-ul este radacina unui arbore in care entitatile sunt frunze

model de incredere strict ierarhic
CA-urile sunt nodurile neterminale ale unui arbore la care radacina este un CA si entiatile sunt frunze
CA-ul parinte emite certificate pentru CA-urile copil
pot fi organizate in paduri pentru care radacinile arborilor au relatii de incredere

certificate inverse si modelul de incredere bigraf
topologia este aceeasi ca in modelul strict ierarhic dar un CA copil poate emite certificate pentru CA-ul parinte
tipurile de certificate

certificat direct
este certificatul emis de CA parinte pentru CA copil

certificat invers
este certificatul emis de CA copil pentru CA parinte

distribuirea si revocarea certificatelor

distribuirea certificatelor

modelul extragere
este cel implementat print-un director de certificate, entitatile extragand certificatul de care au nevoie

modelul promovare
toate certificatele sunt trnsmise periodic tututror entitatilor

retragerea certificatelor

expirarea datei din certificat

notificare manuala
entitatile sunt informate pe un canal out-of-band asupra cheilor revocate

fisier public cu chei revocate
ce contine cheile revocate si care trebuie consultat de catre entiati inainte de a folosi o cheie

liste de revocare a certificatelor (CRL)

certificate de revocare

certificate cu cheie publica ce contin un flag si un timp de revocare si care se folosesc pentru anularea certificatului corespondent
domeniu de securitate: Un sistem care este sub controlul unei singure autoritati si in care entitatile din domeniu au incredere
fiecare entitate

partajeaza un secret sau o parola - in cazul simetric

detine cheia publica autentica a CA- in cazul asimetric

ceea ce permite comunicatia pe un canal sigur cu autoritatea sau cu o alta entitate
increderea intre doua domenii: entitatile A si B apartinand domeniilor D_A si D_B ce au autoritatile T_A si T_B doresc sa comunice; A si B fie

partajeaza o cheie simetrica

partajeaza chei publice de incredere

ambele fiind posibile daca T_A si T_B au o relatie de incredere
A si B delega pe T_A si T_B prin intermediul canalelor sigure (A , T_A) , (T_A , T_B ) , ( B , T_B ) in stabilirea relatiei de incredere ( A , B)
daca T_A si T_B nu au o relatie de incredre directa, vor face apel la T_C in care au ambiele incredere

metode

cheie simetrica de incredere

A cere lui T_A sa obtina o cheie pe care sa o partajeze cu B

T_A si T_B stabilesc o cheie de termen scurt K_AB

T_A si T_B distribuie K_AB lui A si B

A comunica direct cu B utilizand K_AB

cheie publica de incredere

A cere lui T_A cheia publica a lui B

T_A o obtine de la T_B care garanteaza autenticitatea

T_A transfera aceasta cheie lui A

A comunica direct cu B utilizand K_AB

certificat incrucisat
un certificat creat de CA₁ prin care se certifica cheia publica a CA₂
modele de incredere cu mai multe CA-uri: Relatiile de incredere intre CA-uri, in sisteme cu cheie publica, pot fi organizate in mai multe moduri

lanturi de certificate si cai de certificare
o entitate doreste sa obtina o cheie publica autentica, verificand un certicat emis de o alta CA decat CA in care are incredere
calea de certificare este un drum in graful ce contine CA-urile, pentru care nodul initial este CA-ul in care entitatea are incredere si cel final este CA-ul care a emis certificatul pe care entitatea doreste sa-l verificae
un lant de certificate este secventa de certificate emise de CA-urile dintr-o cale de certificare

domenii separate
CA-urile trebuie sa aiba relatii de incredere pentru ca o entitate dintr-un domeniu sa poata comunica criptografic cu o entitate din alt domeniu; implicit CA-urile definesc separate de securitate care nu au relatii de incredere ai entitatile dintr-un domeniu nu pot verifica autenticitatea certificatelor emise in alt domeniu
CA-ul este radacina unui arbore in care entitatile sunt frunze

model de incredere strict ierarhic
CA-urile sunt nodurile neterminale ale unui arbore la care radacina este un CA si entiatile sunt frunze
CA-ul parinte emite certificate pentru CA-urile copil
pot fi organizate in paduri pentru care radacinile arborilor au relatii de incredere

certificate inverse si modelul de incredere bigraf
topologia este aceeasi ca in modelul strict ierarhic dar un CA copil poate emite certificate pentru CA-ul parinte
tipurile de certificate

certificat direct
este certificatul emis de CA parinte pentru CA copil

certificat invers
este certificatul emis de CA copil pentru CA parinte
distribuirea si revocarea certificatelor: distribuirea certificatelor

modelul extragere
este cel implementat print-un director de certificate, entitatile extragand certificatul de care au nevoie

modelul promovare
toate certificatele sunt trnsmise periodic tututror entitatilor

retragerea certificatelor

expirarea datei din certificat

notificare manuala
entitatile sunt informate pe un canal out-of-band asupra cheilor revocate

fisier public cu chei revocate
ce contine cheile revocate si care trebuie consultat de catre entiati inainte de a folosi o cheie

liste de revocare a certificatelor (CRL)

certificate de revocare

certificate cu cheie publica ce contin un flag si un timp de revocare si care se folosesc pentru anularea certificatului corespondent

Protocoale de distribuire a cheilor

2006-01-10T12:56:00.000+02:00

cadrul de lucru: protocol
un algoritm ce specifica pasii prin care doua sau mai multe entitati conclucreaza pentru atingerea unui obiectiv

distribuirea cheilor
un protocol prin care un secret partajat devine disponibil partilor spre uz criptografic viitor

multe dintre protocoalele de distribuire a cheilor implica existenta unei entitati centrale sau a unei entitati de incredere. Aceasta entitate se poate intalni sub diferite denumiri
trusted third party

trusted server

authentication server

key distribution center (KDC)

key translation center (KTC)

certification authority (CA)

transportul cheilor
un protocol prin care partile creeaza sau obtin un secret pe care il transfera intr-un mod sigur intre ele

acordul asupra cheilor
un protocol prin care partile deduc un secret partajat in baza informatiilor asociate fiecarei parti ai nici una dintre parti nu poate prezice rezultatul

schema de predistribuire a cheilor
un caz particular de distribuire a cheilor in care cheile sunt determinate a priori din informatia asociata partilor

distribuirea dinamica a cheilor
un caz particular de distribuire a cheilor in care cheile variaza de la o sesiune la alta

autentificarea cheii
o entitate se asigura ca nici o alta entitate in afara entitatii/entitatilor identificate nu are acces la o anumita cheie secreta

confirmarea cheii
o entitate se asigura ca o alta entitate (posibil neidentificata) este in posesia unei anumite chei secrete

autentificarea explicita a cheii
sunt simultan valabile autentificarea cheii si confirmarea cheii

distribuirea cheii autentificate
un protocol care asigura autentificarea cheii

distribuirea cheilor bazata pe identitate
un protocol de distribuire a cheilor in care informatia de identificare a entitatii se foloseste drept cheie publica

distribuirea independenta de mesaj a cheilor
un protocol de distribuire a cheilor in care sunt implicate doar doua entitati si in care mesajele schimbate intre acestea nu depind de informatia de sesiune

caracteristici ale protocoalelor de distribuire a cheilor

natura autentificarii
o combinatie a urmatoarelor

autentificarea entitatii

autentificarea cheii

confirmarea cheii

reciprocitatea autentificarii
fiecare dintre autentificarile de mai sus pot fi unilaterale sau mutuale

prospetimea cheii
din punctul de vedere al unei entitati o cheie proaspata este o cheie ce nu a mai fost utilizata

controlul cheii

o entitate alege o cheie

cheia este derivata din informatioa asociata partilor si nici o parte nu poate o poate prevedea

eficienta

numarul de mesaje schimbate intre parti

latimea de banda necesara

complexitatea calculelor

posibilitatea de a face calcule off-line

cerinte privitoare la o terta parte

existenta, on-line sau off-line sau inexistenta unei terte parti

gradul de incredere cerut unei terte parti

tipul de certificat utilizat daca este cazul
maniera de distributie a informatiei initiale

nonrepudierea
un protocol trebuie sa asigure o confirmare a primirii cheii

atac pasiv
atacul realizat de catre un adversar care inregistreaza traficul si apoi incearca analiza

atac activ
atacul realizat de catre un adversar ce modifica sau injecteaza mesaje

confidentialitate perfecta inainte
se spune despre un protocol ca are aceasta proprietate daca compromiterea cheilor de lunga durata nu duce la compromiterea cheilor din sesiunile din trecut

vulnerabil la atac cu cheie cunoscuta
se spune despre un protocol ca are aceasta proprietate daca compromiterea cheilor de sesiune din trecut permite unui adversar activ sa compromita cheile de sesiune din viitor sau impersonalizarea in viitor realizata de catre un adversar activ
protocol: un algoritm ce specifica pasii prin care doua sau mai multe entitati conclucreaza pentru atingerea unui obiectiv
distribuirea cheilor: un protocol prin care un secret partajat devine disponibil partilor spre uz criptografic viitor
transportul cheilor: un protocol prin care partile creeaza sau obtin un secret pe care il transfera intr-un mod sigur intre ele
acordul asupra cheilor: un protocol prin care partile deduc un secret partajat in baza informatiilor asociate fiecarei parti ai nici una dintre parti nu poate prezice rezultatul
schema de predistribuire a cheilor: un caz particular de distribuire a cheilor in care cheile sunt determinate a priori din informatia asociata partilor
distribuirea dinamica a cheilor: un caz particular de distribuire a cheilor in care cheile variaza de la o sesiune la alta
autentificarea cheii: o entitate se asigura ca nici o alta entitate in afara entitatii/entitatilor identificate nu are acces la o anumita cheie secreta
confirmarea cheii: o entitate se asigura ca o alta entitate (posibil neidentificata) este in posesia unei anumite chei secrete
autentificarea explicita a cheii: sunt simultan valabile autentificarea cheii si confirmarea cheii
distribuirea cheii autentificate: un protocol care asigura autentificarea cheii
distribuirea cheilor bazata pe identitate: un protocol de distribuire a cheilor in care informatia de identificare a entitatii se foloseste drept cheie publica
distribuirea independenta de mesaj a cheilor: un protocol de distribuire a cheilor in care sunt implicate doar doua entitati si in care mesajele schimbate intre acestea nu depind de informatia de sesiune
caracteristici ale protocoalelor de distribuire a cheilor: natura autentificarii
o combinatie a urmatoarelor

autentificarea entitatii

autentificarea cheii

confirmarea cheii

reciprocitatea autentificarii
fiecare dintre autentificarile de mai sus pot fi unilaterale sau mutuale

prospetimea cheii
din punctul de vedere al unei entitati o cheie proaspata este o cheie ce nu a mai fost utilizata

controlul cheii

o entitate alege o cheie

cheia este derivata din informatioa asociata partilor si nici o parte nu poate o poate prevedea

eficienta

numarul de mesaje schimbate intre parti

latimea de banda necesara

complexitatea calculelor

posibilitatea de a face calcule off-line

cerinte privitoare la o terta parte

existenta, on-line sau off-line sau inexistenta unei terte parti

gradul de incredere cerut unei terte parti

tipul de certificat utilizat daca este cazul
maniera de distributie a informatiei initiale

nonrepudierea
un protocol trebuie sa asigure o confirmare a primirii cheii
natura autentificarii: o combinatie a urmatoarelor

autentificarea entitatii

autentificarea cheii

confirmarea cheii
reciprocitatea autentificarii: fiecare dintre autentificarile de mai sus pot fi unilaterale sau mutuale
prospetimea cheii: din punctul de vedere al unei entitati o cheie proaspata este o cheie ce nu a mai fost utilizata
controlul cheii: o entitate alege o cheie

cheia este derivata din informatioa asociata partilor si nici o parte nu poate o poate prevedea
eficienta: numarul de mesaje schimbate intre parti

latimea de banda necesara

complexitatea calculelor

posibilitatea de a face calcule off-line
cerinte privitoare la o terta parte: existenta, on-line sau off-line sau inexistenta unei terte parti

gradul de incredere cerut unei terte parti
tipul de certificat utilizat daca este cazul: maniera de distributie a informatiei initiale
nonrepudierea: un protocol trebuie sa asigure o confirmare a primirii cheii
atac pasiv: atacul realizat de catre un adversar care inregistreaza traficul si apoi incearca analiza
atac activ: atacul realizat de catre un adversar ce modifica sau injecteaza mesaje
confidentialitate perfecta inainte: se spune despre un protocol ca are aceasta proprietate daca compromiterea cheilor de lunga durata nu duce la compromiterea cheilor din sesiunile din trecut
vulnerabil la atac cu cheie cunoscuta: se spune despre un protocol ca are aceasta proprietate daca compromiterea cheilor de sesiune din trecut permite unui adversar activ sa compromita cheile de sesiune din viitor sau impersonalizarea in viitor realizata de catre un adversar activ
distribuire prin criptare si tehnici simetrice: transportul cheilor prin criptare simetrica

derivarea si transportul cheilor in lipsa unui server

actualizarea punct-la-punct a cheii prin criptare simetrica

actualizarea punct-la-punct a cheii prin prin derivarea cheii si functii neinversabile

transportul cheii fara chei partajate initiale

Kerberos si protocoale cu server

protocolul de autentificare Kerberos

sunt implicate trei entitati: A(client), B(server si verificator) si T(server de autentificare Kerberos)
initial A si B nu partajeaza nici un secret in timp ce T partajeaza cate un secret cu fiecare
scopul lui B este acela de a verifica identitatea lui A si ca efect colateral, stabilirea unei chei partajate
optional A si B se autentifica reciproc si stabilesc o cheie secreta care nu este cunoscuta de T
A cere lui T referinte care sa-i permita sa se autentifice fata de B
T returneaza lui A o cheie de sesiune criptata pentru A si un tichet criptat pentru B
A transmite lui B tichetul si identitatea lui A
A se autentifica fata de B print-un mesaj, ce contine un marcaj de timp, criptat cu cheia de sesiune

E este un algoritm de criptare simetrica

N_A este o informatie aleasa de A; T_A este un marcaj de timp dedus din ceasul local al lui A

L este durata de validitate

A si T partajeaza cheia K_AT iar B si T partajeaza cheia K_BT; tichet_B = E_{K_BT}(k, A, L); autentificator = E_k(A, T_A, A_subcheie)

mesaje
A → T: A, B, N_A

A ← T: tichet_B, E_{K_AT}(k, N_A, L, B)

A → B: tichet_B, autentificator

A ← B: E_k(T_A, B_subcheie)

actiunile
A genereaza informatia N_A si trimite lui T mesajul

T genereaza o cheie de sesiuen k, defineste o perioada de validitate, L, a tichetului (timp de expirare, optional timp de incepere); cripteaza cheia, informatia primita de la A, durata de validitate si identitatea lui B utilizand cheia lui A; T creeaza un tichet criptat cu cheia lui B ce contine cheia,k, identitatea lui A si durata de validitate; ambele sunt transmise lui A

A decripteaza partea de mesaj ce-i este adresata si recupreaza cheia, k, informatia transmisa initial, N_A, durata de validitate, L si identitatea lui B; A verifica ca identitatea lui B si informatia, N_A sunt cele transmisie initila lui T si salveaza L; T cripteaza propria identitate, un marcaj de timp si optional un secret, A_subcheie utilizand cheia de sesiune si transmite lui B

B decripteaza tichetul utilizand cheia, K_BT si recupreaza cheia de sesiuen, k pe care o foloseste pentru decriptarea autentificatorului si verifica

ca identitatea lui A din tichet si din autentificator corespunf

daca marcajul de timp din autentificator este valid

daca timpul local propriu este in intervalul specificat prin L

(optional autentificare mutuala) B cripteaza marcajul de timp al lui A si o subcheie (care sa permita o negociere ulterioara a unei subcehi de sesiune) cu cheia de sesiune, k, si trimite lui A

A decripteza si recupereaza subcheia lui B, daca marcajul de timp corespunde

protocolul cu chei partajate Needham-Schroeder

protocolul Otway-Rees

acordul asupra cheilor prin tehnici simetrice

sistem de distribuire chei (KDS - key distribution system) este o metoda prin care, in timpul unei perioade de initializare, un server de incredere genereaza si distribuie date secrete utilizatorilor ai orice pereche de utilizatori poate sa calculeze o cheie partajata, necunoscuta altor utilizatori, exceptie facand serverul
pentru o pereche de chei fixate, KDS este o scheme de predistributie

KDS j-sigur pentru o pereche de utilizatori, orice coalitie de j sau mai putin utilizatori ce partajeaza datele proprii nu pot calcula cheia partajata de perechea initiala mai bine decat simpla ghicire

limita Blom pentru KDS intr-un KDS j-sigur ce asigura perechi de chei pe m biti, datele secrete stocate de catre fiecare utilizator trebuie sa aiba cel putin m(j+1) biti

sistemul simetric Blom de predistribuire a cheii
transportul cheilor prin criptare simetrica: derivarea si transportul cheilor in lipsa unui server

actualizarea punct-la-punct a cheii prin criptare simetrica

actualizarea punct-la-punct a cheii prin prin derivarea cheii si functii neinversabile

transportul cheii fara chei partajate initiale

Kerberos si protocoale cu server

protocolul de autentificare Kerberos

sunt implicate trei entitati: A(client), B(server si verificator) si T(server de autentificare Kerberos)
initial A si B nu partajeaza nici un secret in timp ce T partajeaza cate un secret cu fiecare
scopul lui B este acela de a verifica identitatea lui A si ca efect colateral, stabilirea unei chei partajate
optional A si B se autentifica reciproc si stabilesc o cheie secreta care nu este cunoscuta de T
A cere lui T referinte care sa-i permita sa se autentifice fata de B
T returneaza lui A o cheie de sesiune criptata pentru A si un tichet criptat pentru B
A transmite lui B tichetul si identitatea lui A
A se autentifica fata de B print-un mesaj, ce contine un marcaj de timp, criptat cu cheia de sesiune

E este un algoritm de criptare simetrica

N_A este o informatie aleasa de A; T_A este un marcaj de timp dedus din ceasul local al lui A

L este durata de validitate

A si T partajeaza cheia K_AT iar B si T partajeaza cheia K_BT; tichet_B = E_{K_BT}(k, A, L); autentificator = E_k(A, T_A, A_subcheie)

mesaje
A → T: A, B, N_A

A ← T: tichet_B, E_{K_AT}(k, N_A, L, B)

A → B: tichet_B, autentificator

A ← B: E_k(T_A, B_subcheie)

actiunile
A genereaza informatia N_A si trimite lui T mesajul

T genereaza o cheie de sesiuen k, defineste o perioada de validitate, L, a tichetului (timp de expirare, optional timp de incepere); cripteaza cheia, informatia primita de la A, durata de validitate si identitatea lui B utilizand cheia lui A; T creeaza un tichet criptat cu cheia lui B ce contine cheia,k, identitatea lui A si durata de validitate; ambele sunt transmise lui A

A decripteaza partea de mesaj ce-i este adresata si recupreaza cheia, k, informatia transmisa initial, N_A, durata de validitate, L si identitatea lui B; A verifica ca identitatea lui B si informatia, N_A sunt cele transmisie initila lui T si salveaza L; T cripteaza propria identitate, un marcaj de timp si optional un secret, A_subcheie utilizand cheia de sesiune si transmite lui B

B decripteaza tichetul utilizand cheia, K_BT si recupreaza cheia de sesiuen, k pe care o foloseste pentru decriptarea autentificatorului si verifica

ca identitatea lui A din tichet si din autentificator corespunf

daca marcajul de timp din autentificator este valid

daca timpul local propriu este in intervalul specificat prin L

(optional autentificare mutuala) B cripteaza marcajul de timp al lui A si o subcheie (care sa permita o negociere ulterioara a unei subcehi de sesiune) cu cheia de sesiune, k, si trimite lui A

A decripteza si recupereaza subcheia lui B, daca marcajul de timp corespunde

protocolul cu chei partajate Needham-Schroeder

protocolul Otway-Rees
acordul asupra cheilor prin tehnici simetrice: sistem de distribuire chei (KDS - key distribution system) este o metoda prin care, in timpul unei perioade de initializare, un server de incredere genereaza si distribuie date secrete utilizatorilor ai orice pereche de utilizatori poate sa calculeze o cheie partajata, necunoscuta altor utilizatori, exceptie facand serverul
pentru o pereche de chei fixate, KDS este o scheme de predistributie

KDS j-sigur pentru o pereche de utilizatori, orice coalitie de j sau mai putin utilizatori ce partajeaza datele proprii nu pot calcula cheia partajata de perechea initiala mai bine decat simpla ghicire

limita Blom pentru KDS intr-un KDS j-sigur ce asigura perechi de chei pe m biti, datele secrete stocate de catre fiecare utilizator trebuie sa aiba cel putin m(j+1) biti

sistemul simetric Blom de predistribuire a cheii
distribuire prin criptare si tehnici asimetrice: transportul cheilor prin criptare cu cheie publica

protocoale fara semnaturi

Needham-Schroeder cu cheie publica

protocoale cu semnaturi

criptarea cheilor semnate

criptare si semnare separat

semnarea cheilor criptate

protocoale de autentificare X.509

este in categoria protocoalelor cu semneaza cheile criptate; recomandarea defineste protocoale de autentificare "strong two-way" si "strong three-way" (cu doua si trei treceri) cu autentificarea mutuala a entitatilor si transportul optional al cheilor, cu marcaje de timp si intrebare-raspuns ai sa raspunda urmatoarelor cerinte:

inf. criptografice primite de entitatea B au fost construite de catre entitatea A, care nu le poate altera ulterior

inf. criptografice primite de entitatea B sunt destinate lui B

inf. criptografice primite de entitatea B sunt proaspete

secretul mutual al cheilor transferate

protocol cu doua treceri
A trimite lui B un mesaj si B raspunde cu un mesaj
in caz de reusita, ambele entitati sunt mutual autentificate si se face transportul cheilor autentificate
Notatie

P_A(x) este rezultatul aplicarii cheii publice a lui A la datele x

S_A(x) este rezultatul aplicarii cheii private de semnare a lui A la datele x

r_A si r_B sunt numere ce nu se refolosesc

cert_A este un certificat ce asociaza entitatea A la o cheie publica adecvata atat pentru criptare cat si pentru verificarea semnaturii

initializarea sistemului

fiecare entitate are propria pereche de chei pentru criptare si semnare

entitatea A trebuie sa obtina si sa autentifice cheia publica de criptare a lui B

mesajele protocolului
fie D_A = (t_A, r_A, B, date₁, P_B(k₁)) si D_B = (t_b, r_B, A, r_A, date₂, P_A(k₂))

A → B: cert_A, D_A, S_A(D_A)

A ← B: cert_B, D_B, S_B(D_B)

actiunile

A obtine marcajul de timp t_A care indica timpul de expirare, genereaza r_A si optional cheia simetrica k₁; date₁ sunt date optionale pentru care se doreste autentificarea originii

B verifica autenticitatea lui cert_A, extrage cheia publica de semnare a lui A si verifica semnatura lui A pe blocul D_A; B verifica ca el este destinatarul mesajului, ca marcajul de timp este valid si ca r_A nu a fost inlocuit (r_A contime o secventa pe care B o compara cu o informatie de stare locala in ceea ce priveste unicitatea pentru intervalul de validitate definit prin t_A)

daca verificarile au succes B dautentifica pe A, decripteaza k₁ utilizand propria cheie privata si o salveaza; A este autentificat
daca se doreste autentificare mutuala, B obtine t_B, genereaza r_B si trimite lui A un mesaj similar

A parcurge aceeasi secventa de actiuni; A si B sunt mutual autentificate; A si B partajeaza sceretele mutual k₁ si k₂

se foloseste aceeasi pereche de chei pentru semnare si criptare; deoarece nu se folosesc identificatori, D_A = D_A (... P_B(...) ...) nu exista garantia ca entitatatea care semneaza, SA(DA) este sursa

protocol cu trei treceri
A si B schimba 3 mesaje; protocolul difera de cel anterior dupa cum urmeaza:
marcajele de timp t_A si t_B sunt setate la zero si nu se verifica

A verifica ca r_A este acelasi ca in primul mesaj

A trimite un al treilea mesaj catre B
A → B: (r_B, B), S_A(r_B, B)

B verifica semnatura cu mesajul in clar, corectitudinea identitatii B si ca r_B este acelasi cu cel initial

protocoale hibride
aceste protocoale aplica o criptare simetrica peste criptarea cu cheie publica si peste semnatura
protocolul Beller-Yacobi
asigura autentificarea mutuala a entitatilor si autentificarea explicita a cheii
a fost prioectat pentru aplicatiile in care exista un dezchilibru intre puterile de calcul ale celor doua parti pentru a minimiza cerintele de putere de calcul ale partii mai slabe; identitatea partii mai slabe ramane ascunsa adversarului
fie A entitatea mai slaba si B entitatea mai puternica; A se autentifica lui B prim semnarea unei intraberi in timp ce B se autentifica lui A demonstrand cunoasterea unei chei pe care numai B insusi o poate recupera

acordul asupra cheilor prin tehnici asimetrice

Diffie-Helllman si protocoale inrudite

acordul Diffie-Hellman asupra cheilor
a fost prima solutie practica la problema distributiei cheilor care a permis celor doua parti sa partajeze un secret fara a cunoaste a priori o alta informatie, pe un canal deschis
A si B trimit cate un mesaj peste un canal deschis, la final A si B partajeaza secretul K
pas premergator, o singura data
se selecteaza un numar prim p si un generator α al lui Z_p^* si se publica

mesaje

A → B: α^x mod p

A ← B: α^y mod p

actiuni

A selecteaza aleator un secret x, 1 ≦ x ≦ p-2 si trimite lui B

B selecteaza aleator un secret x, 1 ≦ x ≦ p-2 si trimite lui A

B calculeaza K = (α^x)^y mod p

A calculeaza K = (α^y)^x mod p

acordul ElGamal intr-o singura trecere

protocoale MTI cu doua treceri

protocolul STS (Station-to-Station)

Chei publice certificate implicit

Gunther

Girault

Protocoale Diffie-Hellman cu chei certificate implicit
transportul cheilor prin criptare cu cheie publica: protocoale fara semnaturi

Needham-Schroeder cu cheie publica

protocoale cu semnaturi

criptarea cheilor semnate

criptare si semnare separat

semnarea cheilor criptate

protocoale de autentificare X.509

este in categoria protocoalelor cu semneaza cheile criptate; recomandarea defineste protocoale de autentificare "strong two-way" si "strong three-way" (cu doua si trei treceri) cu autentificarea mutuala a entitatilor si transportul optional al cheilor, cu marcaje de timp si intrebare-raspuns ai sa raspunda urmatoarelor cerinte:

inf. criptografice primite de entitatea B au fost construite de catre entitatea A, care nu le poate altera ulterior

inf. criptografice primite de entitatea B sunt destinate lui B

inf. criptografice primite de entitatea B sunt proaspete

secretul mutual al cheilor transferate

protocol cu doua treceri
A trimite lui B un mesaj si B raspunde cu un mesaj
in caz de reusita, ambele entitati sunt mutual autentificate si se face transportul cheilor autentificate
Notatie

P_A(x) este rezultatul aplicarii cheii publice a lui A la datele x

S_A(x) este rezultatul aplicarii cheii private de semnare a lui A la datele x

r_A si r_B sunt numere ce nu se refolosesc

cert_A este un certificat ce asociaza entitatea A la o cheie publica adecvata atat pentru criptare cat si pentru verificarea semnaturii

initializarea sistemului

fiecare entitate are propria pereche de chei pentru criptare si semnare

entitatea A trebuie sa obtina si sa autentifice cheia publica de criptare a lui B

mesajele protocolului
fie D_A = (t_A, r_A, B, date₁, P_B(k₁)) si D_B = (t_b, r_B, A, r_A, date₂, P_A(k₂))

A → B: cert_A, D_A, S_A(D_A)

A ← B: cert_B, D_B, S_B(D_B)

actiunile

A obtine marcajul de timp t_A care indica timpul de expirare, genereaza r_A si optional cheia simetrica k₁; date₁ sunt date optionale pentru care se doreste autentificarea originii

B verifica autenticitatea lui cert_A, extrage cheia publica de semnare a lui A si verifica semnatura lui A pe blocul D_A; B verifica ca el este destinatarul mesajului, ca marcajul de timp este valid si ca r_A nu a fost inlocuit (r_A contime o secventa pe care B o compara cu o informatie de stare locala in ceea ce priveste unicitatea pentru intervalul de validitate definit prin t_A)

daca verificarile au succes B dautentifica pe A, decripteaza k₁ utilizand propria cheie privata si o salveaza; A este autentificat
daca se doreste autentificare mutuala, B obtine t_B, genereaza r_B si trimite lui A un mesaj similar

A parcurge aceeasi secventa de actiuni; A si B sunt mutual autentificate; A si B partajeaza sceretele mutual k₁ si k₂

se foloseste aceeasi pereche de chei pentru semnare si criptare; deoarece nu se folosesc identificatori, D_A = D_A (... P_B(...) ...) nu exista garantia ca entitatatea care semneaza, SA(DA) este sursa

protocol cu trei treceri
A si B schimba 3 mesaje; protocolul difera de cel anterior dupa cum urmeaza:
marcajele de timp t_A si t_B sunt setate la zero si nu se verifica

A verifica ca r_A este acelasi ca in primul mesaj

A trimite un al treilea mesaj catre B
A → B: (r_B, B), S_A(r_B, B)

B verifica semnatura cu mesajul in clar, corectitudinea identitatii B si ca r_B este acelasi cu cel initial

protocoale hibride
aceste protocoale aplica o criptare simetrica peste criptarea cu cheie publica si peste semnatura
protocolul Beller-Yacobi
asigura autentificarea mutuala a entitatilor si autentificarea explicita a cheii
a fost prioectat pentru aplicatiile in care exista un dezchilibru intre puterile de calcul ale celor doua parti pentru a minimiza cerintele de putere de calcul ale partii mai slabe; identitatea partii mai slabe ramane ascunsa adversarului
fie A entitatea mai slaba si B entitatea mai puternica; A se autentifica lui B prim semnarea unei intraberi in timp ce B se autentifica lui A demonstrand cunoasterea unei chei pe care numai B insusi o poate recupera
acordul asupra cheilor prin tehnici asimetrice: Diffie-Helllman si protocoale inrudite

acordul Diffie-Hellman asupra cheilor
a fost prima solutie practica la problema distributiei cheilor care a permis celor doua parti sa partajeze un secret fara a cunoaste a priori o alta informatie, pe un canal deschis
A si B trimit cate un mesaj peste un canal deschis, la final A si B partajeaza secretul K
pas premergator, o singura data
se selecteaza un numar prim p si un generator α al lui Z_p^* si se publica

mesaje

A → B: α^x mod p

A ← B: α^y mod p

actiuni

A selecteaza aleator un secret x, 1 ≦ x ≦ p-2 si trimite lui B

B selecteaza aleator un secret x, 1 ≦ x ≦ p-2 si trimite lui A

B calculeaza K = (α^x)^y mod p

A calculeaza K = (α^y)^x mod p

acordul ElGamal intr-o singura trecere

protocoale MTI cu doua treceri

protocolul STS (Station-to-Station)

Chei publice certificate implicit

Gunther

Girault

Protocoale Diffie-Hellman cu chei certificate implicit

Algoritmi semnatura digitala

2006-01-06T12:57:00.000+02:00

algoritmi generali: generarea cheii
fiecare entitate creeaza o cheie privata pentru semnarea mesajelor si o cheie publica pentru verificare
o entitatea A selecteaza o cheie privata ce defineste o multime a transformarilor de semnare S_A = {S_A,k/ k ∈ I} unde fiecare S_A,k este o functie injectiva de la P_s la S

S_A defineste o transformare de verificare V_A :P_sx S → {adevarat, fals} ai

adevarat daca S_A,k(p) = s^*

V_A(p, s^*) =

fals altfel

∀ p ∈ P_h, s^* ∈ S, p = h(p) cu p ∈ P
V_A poate fi calculata fara a cunoaste semnatura privata a emitentului

cheia publica a lui A este V_A si cheia privata este multimea S_A

semnarea/verificarea
o entitatea A produce o semnatura s ∈ S pentru un mesaj p ∈ P ce mai tarziu poate fi verificata de o alta entitate B
semnarea
entitatea A executa
selecteaza un element k ∈ I

calculeaza p = h(p) si s^* = S_A,k(p)

semnatura lui A pentru p este s^*; atat p cat si s^* sunt puse la dispozitia entitatilor care doresc sa verifice semnatura

verificarea
entitatea B executa
obtine cheia publica autentica, V_A a lui A

calculeaza p = h(p) si v = V_A(p, s^*)

accepta semnatura daca si numai daca v = adevarat
ElGamal
DSA: este o varianta a semnaturii ElGamal

generarea cheilor

selecteaza un numar prim q ai 2¹⁵⁹ < q < 2¹⁶⁰

alege t ai 0 ≦ t ≦ 8 si un numar prim p, 2^511+64t < p < 2^511+64t cu proprietatea q|(p-1)

selecteaza un generator α al grupului ciclic de ord q din Z_p^*

selecteaza un element g ∈ Z_p^* si calculeaza α = g^(p-1)/q mod p

daca α = 1 at reia de la pasul anterior

selecteaza aleator un intreg a ai 1 ≦ a ≦ q-1

calculeaza y = α^a mod p

cheia publica a lui A este (p, q, α, y) si cheia privata este a

semnarea/verificarea

semnarea
entitatea A semneaza un mesaj, p, de lungime arbitrara
selecteaza aleator un intreg k, 0 < k < q, k va ramane secret

calculeaza r = (α^k mod p) mod q

calculeaza k^-1 mod q

calculeaza s = (k^-1(h(p)+ar)) mod q

semnatura lui A este (r, s)

in standardul DSS functia h este SHA-1

verificarea
entitatea B verifica semnatura lui A, (r, s) pentru mesajul p
obtine cheia publica autentica a lui A, (p, q, α, y)

verifica ca 0 < r < q si 0 < s < q, altfel respinge semnatura

calculeaza w = s^-1 mod q si h(p)

calculeaza u₁ = (wh(m)) mod q si u₂ = (rw) mod q

calculeaza v = ( (a^u₁ y^u₂) ) mod q

accepta semnatura daca v = r
PKCS#1: aceasta schema nu utilizeaza caracteristica de recuperare a mesajului a schemei RSA si foloseste o functie de dispersie (MD-2 sau MD-5)
Schnorr
Feige-Fiat-Shamir
algoritmi generali: generarea cheii
fiecare entitate creeaza o cheie privata pentru semnarea mesajelor si o cheie publica pentru verificare
o entitatea A selecteaza o cheie privata ce defineste o multime a transformarilor de semnare S_A = {S_A,k/ k ∈ I} unde fiecare S_A,k este o functie injectiva de la P_s la S

S_A defineste o transformare de verificare V_A :S → P_s ai ∀ p ∈ P_s, ∀ k ∈ I, V_A º S_A,k = 1_{P_s}
V_A poate fi calculata fara a cunoaste semnatura privata a emitentului

cheia publica a lui A este V_A si cheia privata este multimea S_A

semnarea/verificarea
o entitatea A produce o semnatura s ∈ S pentru un mesaj p ∈ P ce mai tarziu poate fi verificata de o alta entitate B; mesajul p este recuperat din s
semnarea
entitatea A executa
selecteaza un element k ∈ I

calculeaza p = r(p) si s^* = S_A,k(p)

semnatura lui A este s^*; s^* este pus la dispozitia entitatilor care doresc sa verifice semnatura

verificarea
entitatea B executa
obtine cheia publica autentica, V_A a lui A

calculeaza p = V_A(s^*)

verifica ca p ∈ P_r si in acest caz accepta semnatura

recupereaza mesajul p din p calculand r^-1(p)

functia redundanta r si inversa sa sunt cunoscute public; selectia lui r este critica pentru securitatea sistemului
RSA: atat spatiul de semnare P_s cat si spatiul semnaturilor S sunt reprezentate de Z_n

generarea cheilor
fiecare entitate creeaza o cheie publica RSA si o cheie privata corespondenta; o entitate A executa
genereaza doua numere prime distincte, p si q, de acceasi marime

calculeaza n = pq si φ = (p-1)(q-1)

selecteaza aleator in intreg e, 1 < e < φ ai cmmdc(e, φ) = 1

calculeaza intregul (Euclid extins) d, 1 < d < φ ai ed ≡ 1 mod φ

cheia publica a lui A este (n, e) si cheia privata este d

semnarea/verificarea
entitatea A semneaza un mesaj p ∈ P si oricare alta entitate B poate verifica smenatura lui A si recupera mesajul p din semnatura
semnarea
o entitate A executa
calculeaza p = r(p) ca un intreg in intervalul [0, n-1]

calculeaza s = p^d mod n

semnatura lui A pentru p este s

verificarea
o alta entitate B executa
obtine cheia publica autentica a lui A, (n, e)

calculeaza p = s^e mod n

verifica ca p ∈ P_r si daca nu rejecteaza semnatura

recupereaza mesajul p = r^-1(p)
Rabin
Nyberg-Rueppel

DSS PKCS#1

Algoritmi functii dispersie - sumar

2006-01-05T17:55:00.000+02:00

MDC: functii hash bazate pe cifruri bloc
valoarea de hash are aceeasi lungime cu cea a blocului cifrat sau lungime dubla (lungime simpla si lungime dubla)

cifru bloc (n, r)
un cifru bloc care defineste o functie de la multimea textelor in clar de lungime n in biti la multimea textelor cifrate de lungime n biti, folosinf o cheie de lungime r biti; E_k(x) este criptarea lui x cu cheia k

functie hash iterata
este o functie hash, h, care primeste o intrare x de lungime finita pe care o imparte in blocuri x_i de lungime r, eventual adauga biti la x pentru a obtine o lungime divizibila cu r; fiecare bloc x_i este prelucrat de o functie hash de lungime fixa, f, care se numeste functia de compresie a lui h; un rezultat intermediar H(x_i) = f(H(x_i-1) , x_i)

rata unei functii de hash iterate, h
care are o functie de compresi f ce realizeaza s criptari de bloc pentru a procesa un bloc de mesaj de lungime n, este 1/s

MDC-uri de lungime simpla cu rata 1
componente comune

un cifru E_k cu lungimea blocului n

o functie g care mapeaza intrarile de n biti catre cheile K

o valoare intiala, pe n biti, IV

pentru urmatorii algoritmi
Matyas-Meyer-Oseas

intrare: sirul de biti, x

iesire: valoarea de hash a lui x

intrarea x este impartita in blocuri de n biti si completata, x₁x₂...x_t

iesirea H_t este definita de: H₀ = IV, H_i = E_{g(H_i-1)}(x_i) ⊕ x_i, 1 ≦ i ≦ t

Davies-Meyer

intrare: sirul de biti, x

iesire: valoarea de hash a lui x

intrarea x este impartita in blocuri de n biti si completata, x₁x₂...x_t

iesirea H_t este definita de: H₀ = IV, H_i = E_{x_i}(H_i-1) ⊕ H_i-1, 1 ≦ i ≦ t

Miyaguchi-Preneel

intrare: sirul de biti, x

iesire: valoarea de hash a lui x

intrarea x este impartita in blocuri de n biti si completata, x₁x₂...x_t

iesirea H_t este definita de: H₀ = IV, H_i = E_{g(H_i-1)}(x_i) ⊕ x_i ⊕ H_i-1, 1 ≦ i ≦ t

MDC-uri de lungime dubla: MDC-2 si MDC-4
MDC-2 si MDC-4 necesita 2 si respectiv 4 operatii de cifru bloc pentru un bloc de hash; folosesc 2 si 4 iteratii Matyas_Meyer_Oseas pentru a produce un hash de lungime dubla; cand sunt folosite ca in specificatia orginala, cu DES ca cifru bloc, produc valori de hash de 128 biti

functii hash ad-hoc bazate pe MD4

MD4
proiectat pentru implementare soft pe masini de 32 biti; motive de securitate au condus la aparitia MD5

MD5

intrare: un sir de biti de lungime arbitrara b ≧ 0

iesire: valoarea de hash a lui pe 128 biti

SHA-1, SHA-256, SHA-512, SHA-384

functii hash bazate pe aritmetica modulo

MASH-1, MASH-2
functii hash bazate pe cifruri bloc: valoarea de hash are aceeasi lungime cu cea a blocului cifrat sau lungime dubla (lungime simpla si lungime dubla)

cifru bloc (n, r)
un cifru bloc care defineste o functie de la multimea textelor in clar de lungime n in biti la multimea textelor cifrate de lungime n biti, folosinf o cheie de lungime r biti; E_k(x) este criptarea lui x cu cheia k

functie hash iterata
este o functie hash, h, care primeste o intrare x de lungime finita pe care o imparte in blocuri x_i de lungime r, eventual adauga biti la x pentru a obtine o lungime divizibila cu r; fiecare bloc x_i este prelucrat de o functie hash de lungime fixa, f, care se numeste functia de compresie a lui h; un rezultat intermediar H(x_i) = f(H(x_i-1) , x_i)

rata unei functii de hash iterate, h
care are o functie de compresi f ce realizeaza s criptari de bloc pentru a procesa un bloc de mesaj de lungime n, este 1/s

MDC-uri de lungime simpla cu rata 1
componente comune

un cifru E_k cu lungimea blocului n

o functie g care mapeaza intrarile de n biti catre cheile K

o valoare intiala, pe n biti, IV

pentru urmatorii algoritmi
Matyas-Meyer-Oseas

intrare: sirul de biti, x

iesire: valoarea de hash a lui x

intrarea x este impartita in blocuri de n biti si completata, x₁x₂...x_t

iesirea H_t este definita de: H₀ = IV, H_i = E_{g(H_i-1)}(x_i) ⊕ x_i, 1 ≦ i ≦ t

Davies-Meyer

intrare: sirul de biti, x

iesire: valoarea de hash a lui x

intrarea x este impartita in blocuri de n biti si completata, x₁x₂...x_t

iesirea H_t este definita de: H₀ = IV, H_i = E_{x_i}(H_i-1) ⊕ H_i-1, 1 ≦ i ≦ t

Miyaguchi-Preneel

intrare: sirul de biti, x

iesire: valoarea de hash a lui x

intrarea x este impartita in blocuri de n biti si completata, x₁x₂...x_t

iesirea H_t este definita de: H₀ = IV, H_i = E_{g(H_i-1)}(x_i) ⊕ x_i ⊕ H_i-1, 1 ≦ i ≦ t

MDC-uri de lungime dubla: MDC-2 si MDC-4
MDC-2 si MDC-4 necesita 2 si respectiv 4 operatii de cifru bloc pentru un bloc de hash; folosesc 2 si 4 iteratii Matyas_Meyer_Oseas pentru a produce un hash de lungime dubla; cand sunt folosite ca in specificatia orginala, cu DES ca cifru bloc, produc valori de hash de 128 biti
Matyas-Meyer-Oseas: intrare: sirul de biti, x

iesire: valoarea de hash a lui x

intrarea x este impartita in blocuri de n biti si completata, x₁x₂...x_t

iesirea H_t este definita de: H₀ = IV, H_i = E_{g(H_i-1)}(x_i) ⊕ x_i, 1 ≦ i ≦ t
Davies-Meyer
Miyaguchi-Preneel: intrare: sirul de biti, x

iesire: valoarea de hash a lui x

intrarea x este impartita in blocuri de n biti si completata, x₁x₂...x_t

iesirea H_t este definita de: H₀ = IV, H_i = E_{g(H_i-1)}(x_i) ⊕ x_i ⊕ H_i-1, 1 ≦ i ≦ t
functii hash ad-hoc bazate pe MD4: MD4
proiectat pentru implementare soft pe masini de 32 biti; motive de securitate au condus la aparitia MD5

MD5

intrare: un sir de biti de lungime arbitrara b ≧ 0

iesire: valoarea de hash a lui pe 128 biti

SHA-1, SHA-256, SHA-512, SHA-384
functii hash bazate pe aritmetica modulo: MASH-1, MASH-2
MAC: MAC bazat pe cifruri bloc

MAC construit din MDC

MAC ad hoc

MAC pentru cifru flux

MD-5 familia SHA

Criptarea cu cheie publica

2006-01-05T15:12:00.000+02:00

Schema de criptare cu cheie publica: este o tripleta (G, E, D) de algoritmi PTP care satisfac urmatoarele:

algoritmul de generare a cheii
un algoritm PTP, G, care primeste ca intare o sceventa l^k (parametrul de securitate) si produce o pereche (e, d) unde e se numeste cheia publica si d este cheia privata corespondenta; (e, d) ∈ G(l^k) este o pereche de chei de criptare/decriptare

algoritmul de criptare
un algoritm PTP, E, care primeste ca intrare:

un parametru de securitate l^k

o cheie publica e ∈ G(l^k)

un text in clar m ∈ {0,1}^k

si produce un text cifrat c ∈ {0,1}^k, c ∈ E(l^k, e, m)

algoritmul de decriptare
un algoritm PTP, D, care primeste ca intrare

un parametru de securitate l^k

o cheie privata d ∈ G(l^k)

un text cifrat c ∈ E(l^k, e, m)

si produce un text m' ∈ {0, 1}^* ai

∀ (e, d) ∈ G(l^k)

∀ m

∀ c ∈ E(l^k, e, m)

prob(D(l^k, e, m) ≠ m') este neglijabila
Obs. definitie: singura diferenta fata de definitia unui sistem de criptare cu cheie secreta (vezi blogul "Cifru") este ca adversarul cunoaste cheia publica

textele in clar cu lungime diferita de k (lungimea cheii de criptare) vor fi criptate dupa spargerea in blocuri de lungime k ai
E_e(a₁a₂...a_la_l+1) = E_e(a₁)E_e(a₂)...E_e(a_l)E_e(a_l+1) unde |a₁|=|a₂|=...=|a_l|=k si |a₁|⇔k
Modelul functiei cu trapa: G primeste ca intare parametrul de securitate l^k si prduce perechi (f, t_f) unde f este o functie cu trapa si t_f este trapa

∀ m, E(f, m) = f(m)

fiind date c ∈ E(f, m) si t_f, D(t_f,c) = f^-1(c) = f^-1(f(m)) = m
RSA: colectii RSA de posibile functii cu trapa
fie p, q prime, Z_n^* grupul multiplicativ cu ordinul φ(n) = (p-1)(q-1) si e ∈ Z_p-1 relativ prim cu φ(n); setul de indici va fi I={(n, e) / n = pq, |p|=|q|} si trapa ptr. (n, e) este d ai ed = 1 mod φ(n); RSA = {RSA_{(n, e)} : Z_n^* → Z_n^*}_{(n, e) ∈ I} unde RSA_{(n, e)}(x) = x^e mod n

spatii rare de mesaje
ptr o pereche (n, e) fie este greu de inversat RSA_{(n, e)} pentru toti x din Z_n^* in afara unei fractiuni neglijabile, fie este usor de inversat pentru orice x

generarea cheilor
o entitate A executa:
se genereaza aleator doua numere prime distincte de aceeasi marime, p si q

se calculeaza n = pq si φ=(p-1)(q-1)

se selecteaza aleator un interg, e, 1 < e < φ ai cmmdc(e, φ) = 1

se calculeaza (Euclid extins) intregul d, 1 < d < φ ai ed ≡ 1 mod φ

cheia publicA A este (n, e) si cheia privata a lui A este d
e se numeste exponent de criptare, d se numeste exponent de decriptare si n se numeste modul

criptarea/decriptarea B cripteaza un mesaj m pentru A pe care acesta il va decripta

criptarea

obtine cheia publica (n, e) autentica a lui A

reprezinta mesajul m ca un intreg in intervalul [0, n-1]

calculeaza c = m^e mod n

trimite c lui A

decriptarea

foloseste cheia privata, d, pentru a obtine m = e^d mod n
Rabin: f_n(m) ≡ m² mod n unde n = pq cu p si q prime

f_n^-1(m²) = x ai x² = m² mod n
si ptr. a identifica una dintre cele 4 radacini se poate poate folosi intreg spatiul de mesaje daca acesta este rar in Z_n^*

generarea cheilor
fiecare entitate, A, creeaza o cheie publica si o cheie privata
se genereaza aleator doua numere prime distincte de aceeasi marime, p si q

se calculeaza n = pq

cheia publica a lui A este n, cheia privata a lui A este (p, q)

criptarea/decriptarea
B cripteaza un mesaj, m, pentru A pe care acesta il decripteaza
criptarea

obtine cheia publica a lui A

reprezinta mesajul, m, ca un intreg in multimea {0, 1, ..., n-1}

calculeaza c = m² mod n

trimite c lui A

decriptarea

calculeaza cele 4 radacini m₁, m₂, m₃, m₄ pentru c

A decide care dintre radacini este m
rucsace: sisteme bazate pe problema NP-completa, a rucsacului:
fie un vector a=(a₁, a₂, ..., a_n) de intregi si C o valoare tinta; sa se determine daca exista un vector x ∈ {0, 1}ⁿ ai a x = C
vectorul a este cheia publica; textul criptat c = m a unde m este textul clar

Merkle-Hellman

Chor-Rivest
ElGamal: generarea cheilor
entitatea A creeaza cheile
genereaza aleator un numar prim, p si un generator, α, al grupului multiplicativ Z_p^*

selecteaza aleator un inter, a, 1 ≦ a ≦ p-2 si calculeaza α^a mod p

cheia publica a lui A este (p,α,α^a) iar cheia privata este a

criptarea/decriptarea
B cripteaza un mesaj, m, pentru A pe care A il decripteaza
criptarea

obtine cheia publica, (p,α,α^a), autentica

reprezinta mesajul ca un intreg in multimea {0, 1, ..., p-1}

selecteaza aleator un intreg, k, 1 ≦ k ≦ p-2

calculeaza γ = α^k mod p si δ = m (α^a)^k mod p

trimite textul cifrat c = (γ, δ) lui A

decriptarea
A decripteaza c pentru a obtine m
foloseste cheia privata α pentru a calcula γ^p-1-a mod p

afla pe m calculand (γ^-a) δ mod p
McEliece
probabilistic: schemele RSA, Rabin si rucsac sunt deterministe: ptr. o cheie publica fixata un text in clar este intotdeuana criptat in acelasi text criptat

Goldwasser-Micali

Blum-Goldwasser

AES - sumar

2006-01-04T17:45:00.000+02:00

cripteaza blocuri de 128 biti utilizand chei de 128, 192 sau 256 biti, operatiile fiind realizate la nivel de octet; fiecare octet este privit ca un element al GF(2⁸) la care polinomul ireductibil este x⁸+x⁴+x³+x+1
intrarea si iesirea sunt vectori unidimensionali obtinuti prin partitionarea mesajului in octeti cu adresarea in[i] sau out[i] unde 0 ≦ i ≦ 4Nb-1 si Nb=N/32=4 (N este lungimea mesajului)
operatiile intermediare se efectueaza asupra unui vector bidimensional ce are 4 randuri si Nb coloane denumit State
corespondenta intre intrare si stare respectiv stare si iesire este de forma:
s[r, c] = in [r+4c] cu 0 ≦ r ≦ 4 si 0 ≦ c < Nb
out[r+4c] = s[r, c]
lungimea cheii este reprezentata prin Nk = 4, 6 sau 8
numarul de runde este Nr =10, 12 sau 14
lungimea cheii (Nk cuvinte) lungimea blocului (Nb cuvinte) numarul de runde (Nr)

AES-128 4 4 10

AES-192 6 4 12

AES-256 8 4 14

expandarea cheii
genereaza Nb(Nr+1) cuvinte pornind de la Nb cuvinte (de 4 octeti), fiecare din cele Nr runde necesitand Nb cuvinte; cheile rezulta sub forma unui vector unidimensional [w_i] cu 0 ≦ i ≦ Nb(Nr+1)
KeyExpansion (byte key[4*Nk], word w[Nb*(Nr+1)], Nk)

begin
	word temp
	i = 0
	while (i < Nk)
		w[i] = word(key[4i], key[4i+1], key(4i+2), key[4i+3])
		i = I=1
	end while
	i=Nk
	while (i < Nb * (Nr+1))
		temp = w[i-1]
		if (i mod Nk = 0)
			temp = SubWord(RotWord(temp)) xor Rcon[i/Nk]
		else if (Nk > 6 and i mod Nk =4)
			temp = SubWord(temp)
		end if
		w[i] = w[i-Nk] xor temp
		i = i+1
	end while
end

SubWord() este o functie care aplica Sbox cate unui cuvant o data
RotWord() este o functie care transforma un cuvant [a₀, a₁, a₂, a₃] in cuvantul [a₁, a₂, a₃, a₀]
Rcon[i] = ( a^i-1, '00', '00', '00'), a fiind un element generator al lui GF(2⁸)

algoritm criptare
Cipher( byte in[4*Nb] , byte out[4*Nb] , word w[Nb*(Nr+1)])

begin
	byte state [4, Nb]
	state = in
	AddRoundKey (state, w[0, Nb-1])
	for round = 1 step 1 to Nr-1
		SubBytes(state)
		ShiftRows(state)
		MixColumns(state)
		AddRoundKey(state, w[roundNb, (round+1)Nb-1])
	end for
	SubBytes(state)
	ShiftRows(state)
	AddRoundKey(state, w[NrNb, (Nr+1)Nb-1)
	out = state
end

functia de runda este compusa din 4 transformari orientate octet:
- susbstitutie SubBytes(state)
  neliniara, fiecare octet al starii este substituit independent, ce foloseste o tabela de substitutie formata prin compunerea a doua transformari
  - orice byte nenul se inlocuieste cu inversul sau in GF(2₈)
  - rezultatul este modificat printr-o transformare afina peste Z₂
    
    y₀ 1 0 0 0 1 1 1 1 x₀ 1
    
    y₁ 1 1 0 0 0 1 1 1 x₁ 1
    
    y₂ 1 1 1 0 0 0 1 1 x₂ 0
    
    y₃ = 1 1 1 1 0 0 0 1 x₃ + 0
    
    y₄ 1 1 1 1 1 0 0 0 x₄ 0
    
    y₅ 0 1 1 1 1 1 0 0 x₅ 1
    
    y₆ 0 0 1 1 1 1 1 0 x₆ 1
    
    y₇ 0 0 0 1 1 1 1 1 x₇ 0
  rezultand o matrice inversabila de substitutie (Sbox)
  
  0 1 2 3 4 5 6 7 8 9 a b c d e f
  
  0 63 7c
  
  1 ca 82
  
  2 b7 fd
  
  3 04 c7
  
  4 09 83
  
  5 53 d1
  
  6 d0 ef
  
  7 51 a3
  
  8 cd 0c
  
  9 60 81
  
  a e0 32
  
  b e7 c8
  
  c ba 78
  
  d 70 3e
  
  e e1 f8
  
  f 8c a1
- alunecare la nivel de rand ShiftRows(state)
  primul rand se lasa neschimbat iar pentru ultimele trei randuri se face o alunecare
  s[r, c] = s[r, (c+shift(r, Nb))mod Nb] unde 0 < r < 4, 0 ≦ c < Nb
  si shift(r, Nb) este dat de
  
  Nb/r 1 2 3
  
  4 1 2 3
  
  6 1 2 3
  
  8 1 3 4
- mixare pe coloana MixColumns(state)
  opereaza asupra starii, coloana cu coloana, tratand fiecare coloana ca un polinom de grad 3 cu coeficienti in GF(2⁸) care este inmultit modulo x⁴+1 cu un polinom fix a(x)='03'x³+'01'x²+'01'x+'02'
  sub forma matriciala
  
  s_{0, c} '02' '03' '01' '01' s_{0, c}
  
  s_{1, c} = '01' '02' '03' '01' s_{1, c}
  
  s_{2, c} '01' '01' '02' '03' s_{2, c}
  
  s_{3, c} '03' '01' '01' '02' s_{3, c}
- adaugarea unei chei de runda AddRoundKey(...)
  XOR intre stare si cheia de runda; fiecare cheie de runda consta in Nb cuvinte
  [s_{0, c}, s_{1, c}, s_{2, c}, s_{3, c}] = [s_{0, c}, s_{1, c}, s_{2, c}, s_{3, c}] ⊕ [w_{runda * Nb + c}] unde 0 ≦ c < Nb, 0 ≦ runda < Nr

algoritm decriptare
InvCipher( byte in[4*Nb] , byte out[4*Nb] , word w[Nb*(Nr+1)])

begin
	byte state [4, Nb]
	state = in
	AddRoundKey (state, w[NrNb, (Nr+1)Nb-1])
	for round = Nr-1 step -1 downto 1
		InvShiftRows(state)
		InvSubBytes(state)
		AddRoundKey(state, w[roundNb, (round+1)Nb-1])
		InvMixColumns(state)
	end for
	InvShiftRows(state)
	InvSubBytes(state)
	AddRoundKey(state, w[0, Nb-1)
	out = state
end

functia de runda este compusa din 4 transformari
- InvShiftRows()
  este inversa transformarii ShiftRows() astfel ca s[r, (c+shift(r, Nb)) mod Nb] = s[r, c]
- InvSubBytes este inversa SubBytes()
- InvMixColumns() este inversa transformarii MixColumns()
  
  s_{0, c} '0e' '0b' '0d' '09' s_{0, c}
  
  s_{1, c} = '09' '0e' '0b' '0d' s_{1, c}
  
  s_{2, c} '0d' '09' '0e' '0b' s_{2, c}
  
  s_{3, c} '0b' '0d' '09' '0e' s_{3, c}
- AddRoundKey() este aceeasi (este propria inversa)
cheile de runda sunt identice cu cele folosite la criptare

algoritm decriptare echivalent
EqInvCipher( byte in[4*Nb] , byte out[4*Nb] , word w[Nb*(Nr+1)])

begin
	byte state [4, Nb]
	state = in
	AddRoundKey (state, dw[NrNb, (Nr+1)Nb-1])
	for round = Nr-1 step -1 downto 1
		InvSubBytes(state)
		InvShiftRows(state)
		InvMixColumns(state)
		AddRoundKey(state, dw[roundNb, (round+1)Nb-1])
	end for
	InvSubBytes(state)
	InvShiftRows(state)
	AddRoundKey(state, dw[0, Nb-1)
	out = state
end

functia de runda este compusa din 4 transformari
- InvShiftRows()
  este inversa transformarii ShiftRows() astfel ca s[r, (c+shift(r, Nb)) mod Nb] = s[r, c]
- InvSubBytes este inversa SubBytes()
- InvMixColumns() este inversa transformarii MixColumns()
  
  s_{0, c} '0e' '0b' '0d' '09' s_{0, c}
  
  s_{1, c} = '09' '0e' '0b' '0d' s_{1, c}
  
  s_{2, c} '0d' '09' '0e' '0b' s_{2, c}
  
  s_{3, c} '0b' '0d' '09' '0e' s_{3, c}
- AddRoundKey() este aceeasi (este propria inversa)
algoritmul pentru chei se modifica prin adaugarea urmatoarelor linii

for i = 0 step 1 to (Nr+1)*Nb-1

dw[i] = w[i]

end for

for round = 1 step 1 to Nr-1

InvMixColumns(dw[round*Nb, (round+1)*Nb-1])

end for

FIPS 197

Memento algebra - continuare

2006-01-04T13:00:00.000+02:00

inelul F[x] de polinoame in x peste campul F: fie (F,+,.) un camp; un polinom de variabila x peste F este o expresie de forma f(x) = a₀+a₁ . x + a₂ . x² + ... + a_n . xⁿ unde coeficientii a_i sunt elemente ale lui F si n este un intreg pozitiv
cel mai mare i ptr. care a_i ≠ 0 se numeste gradul lui f(x)
∀ F, inelul F[x] este un domeniu de integritate
polinom ireductibil: fie f(x) ∈ F[x] un polinom cu gradul cel putin 1. Se spune ca f(x) este ireductibil peste F daca nu poate fi scris ca produsul a doua polinoame din F[x], fiecare de grad pozitiv
impartire: fie g(x), h(x) ∈ F[x] cu h(x) ≠ 0 at g(x) = c(x)h(x) + r(x) cu grad r(x) < grad h(x), c(x) si r(x) sunt unice
c(x) se noteaza g(x) div h(x0 si r(x) se noteaza g(x) mod h(x)
divizor: fie g(x), h(x) ∈F[x]; h(x) divide pe g(x) , h(x)|g(x) daca g(x) mod h(x) = 0
congruenta: fie g(x), h(x) ∈F[x]; se spune ca g(x) este congruent cu h(x) modulo f(x) daca f(x)| g(x)-h(x) si se noteaza g(x) ≡ h(x) (mod f(x))
congruenta are proprietatile unei relatii de echivalenta: reflexivitate, simetrie si tranzitivitate
clase de echivalenta: multimea claselor de echivalenta modulo f(x) ale polinoamelor peste F[x] se noteaza F[x]/(f(x))
F[x]/(f(x)) cu adunarea si inmultirea modulo f(x) formeaza un inel comutativ
daca f(x) este ireductibil peste F[x] at. F[x]/(f(x)) este camp
camp finit: un camp F care are un numar finit de elemente
ordinul lui F este numarul sau de elemente
existenta si unicitate: daca F este un camp finit at F contine p^m elemente unde p este prim si m este un intreg pozitiv
ptr fiecare p^m exista un camp finit unic (clasa de izomorfism) de ordinul p^m; campul se noteaza F_p^m sau GF(p^m)
T: daca F este un camp de ordin q=p^m cu p prim at. caracteristica lui F_q este p
F_q contine o copie a lui Z_p ca subcamp
∀ subcamp al lui F_q are ordinul pⁿ unde n este un divizor pozitiv al lui m
grupul multiplicativ F^*_q: elementele nenule ale lui F_q formeaza grup cu inmultirea
F^*_q grup ciclic: de ordinul q-1
element generator: un generator al lui F^*_q se numeste generator pentru F_q
T: ( a + b ) ^{p^t} = a ^{p^t} + b ^{p^t} cu a, b ∈ F_q si p caracteristica campului
Euclid in Z_p[x]: cmmdc
fie g(x), h(x) ∈ Z_p[x], ambele nenule; cmmdc(g(x), h(x)) este monomul cu cel mai mare grad care divide pe g(x) si pe h(x)

Z_p[x] este domeniu unic de descompunere in factori
∀ f(x) ∈ Z_p[x] admite o descompunere in factori de forma f(x) = a f₁(x)^e₁f₂(x)^e₂...f_k(x)^e_k unde f_i(x) sunt monoame ireductibile in Z_p[x] si e_i sunt intregi pozitivi iar a ∈ Z_p
descompunerea este unica

algoritm Euclid

intrare: g(x), h(x) ∈ Z_p[x]

iesire: cmmdc(g(x), h(x))

while h(x) ≠ 0 do
r(x)=g(x) mod h(x) , g(x)=h(x) , h(x) = r(x)

return g(x)

algoritm cu O(m²) operatii in Z_p sau O(m²(lg p)²) operatii binare

algoritm Euclid extins

intrare: g(x), h(x) ∈ Z_p[x]

iesire: d(x) = cmmdc(g(x), h(x)) si doua polinoame s(x) , t(x) ∈ Z_p[x] care satisfac: s(x)g(x) + t(x)h(x) = d(x)

if h(x) = 0 then d(x)=g(x), s(x) = 1, t(x)=0 , return (d(x),s(x),t(x0)

else s₂(x)=1, s₁(x)=0, t₂(x)=0, t₁(x)=1

while h(x) ≠ 0 do
q(x)=g(x) div h(x), r(x)=g(x)-h(x)q(x)
s(x)=s₂(x)-q(x)s₁(x), t(x)=t₂(x)-q(x)t₁(x)
g(x)=h(x), h(x)=r(x)
s₂(x)=s₁(x), s₁(x)=s(x), t₂(x)=t₁(x), t₁(x)=t(x)

d(x)=g(x), s(x)=s₂(x), t(x)=t₂(x)

return (d(x),s(x),t(x0)

algoritm cu O(m²) operatii in Z_p sau O(m²(lg p)²) operatii binare
aritmetica polinoamelor

Memento algebra

2006-01-04T10:24:00.000+02:00

relatie binara: o relatie binara pe o multime S este o functie * : S x S → S; daca (a,b) ∈ S x S at. a*b indica imaginea lui (a,b)
* este asociativa daca: x*(y*z) = (x*y)*z, ∀ x, y, x ∈ S
e ∈ S este element neutru fata de * daca: x*e = e*x = x, ∀ x ∈ S
daca e ∈ S este elem. neutru pentru *, pentru un x ∈ S fixat se spune ca y ∈ S este element invers daca: x*y = e si y*x = e
* este comutativa daca: x*y = y*x, ∀x, y ∈ S
a ∈ S este idempotent fata de * daca: a*a = a
z ∈ S este un zero pentru * daca: z*x = z si x*z=z, ∀ x ∈ S
grup: un grup este o pereche ordonata (G, *) unde G este o multime si * este o relatie binara pe G care satisface proprietatile
asociativitate
poseda element neutru
∀ x ∈ G este inversabil
grup abelian: un grup (G,*) pentru care * este comutativa
T: daca (G,*) este un grup atunci
elementul neutru este unic
elementul invers este unic
T: fie (G,*) un grup care are elementul neutru e. At:
daca a*c=a*b at. c=b
daca c*a = b*a at. c = b
fie a, b ∈ G, ∃ x ∈ G, unic. ai a*x=b
fie a, b ∈ G, ∃ x ∈ G, unic. ai x*a=b
daca a*b=a at b=e
daca b*a = a at b=e
daca a*a = a at. a = e
(a^-1)^-1 = a
(a * b)^-1 = b^-1 * a^-1
T: fie (G,*) un grup cu e elementul neutru; ∀ n, m ∈ Z avem:
aⁿ*a^m = a^n+m
(aⁿ)^m = a^nm
si daca a*b = b*a at (a * b)ⁿ = aⁿ * bⁿ
subgrup: fie (G,.) un grup; un subgrup al lui G este o submultime H a lui G care satisface urmatoarele:
e ∈ H
daca a, b ∈ H at a.b ∈ H
daca a ∈ H at a^-1 ∈ H
ordinul grupului: fie (G,*) un grup; numarul de elemente ale lui G se numeste ordinul lui G si se noteaza |G|
ordinul unui element: fie a un element al grupului G; daca ∃ n ∈ N ai aⁿ = e se spune ca a are un ordin finit si se defineste o(a)=min{n∈N/aⁿ = e}; daca aⁿ ≠ e at se spune ca a are un ordin infinit si se defineste o(a) = ∞
subgrup generat de un element: fie a un element al lui G. Se defineste subgrupul lui G generat de catre a <a> = {aⁱ, i∈ Z}
T: ∀ a ∈ G, (G, *) grup at. <a> este subgrup al lui G care il contine pe a si este cel mai mic subgrup cu aceasta proprietate
T: ∀ a ∈ G, (G, *) grup; daca o(a)=1 at <a> = {e}; daca o(a)=n at <a> = {e, a, a², ..., a^n-1 } si elementele e, a, a², ..., a^n-1 sunt distincte ai o(a)=|<a>|
T: daca G este un grup finit at ∀ a ∈ G are ordin finit
secventa de ordine: fie g={ g₁, g₂ , ... , g_n } , o(g_i) = k_i ptr. i = 1, 2, ..., n; secventa { k₁, k₂ , ... , k_n } este secventa de ordine a grupului G; se presupune ca elementele sunt ordonate ai k₁ ≦ k₂ ≦ ... ≦ k_n
homomorfism, izomorfism de grupuri: fie (G,*) si (H,+) doua grupuri. O functie f : G → H este un homomorfism de la G la H daca f(a*b) = f(a) + f(b), ∀ a, b ∈ G. Daca f este bijectiva atunci se numeste izomorfism de la G la H
T: fie (G,*) si (H,+) grupuri, f : G → H un homomorfism, e_G si e_H elem. neutre at.
f(e_G) = e_H
f(a^-1) = f(a)^-1
f(aⁿ) = f(a)ⁿ, ∀ n ∈ Z
T: fie (G,*) si (H,+) grupuri, f : G → H un izomorfism at. o(a) = o(f(a)), ∀ a ∈ G
G si H au acelasi numar de elemente cu acelasi ordine
T: daca G ≈ H si G abelian at. H abelian
grup ciclic: ∃ a ∈ G ai <a> = G iar a se numeste generator
T: daca G ≈ H si G ciclic at. H ciclic
T: fie a elem. al lui G, at.
daca o(a) = ∞ at <a> ≈ Z
daca o(a) = n at <a> ≈ Z_n
coset: fie G un grup si H un subgrup al lui G; ∀ a ∈ G se defineste a*H = { a*h / h ∈ H} , cosetul lui H in G generat de a
T: fie G un grup finit si H un subgrup al lui G, a, b ∈ G at.
a ∈ a*H
|a*H|=|H|
daca a*H si b*H nu sunt disjuncte at. a*H = b*H
T(Lagrange): daca G este un grup fint si H este un subgrup al lui G at |H| divide pe |G|
T: daca G este un grup finit si a elem. al lui G at o(a) divide pe |G|
daca G este un grup finit si a elem. al lui G at a^|G| = e
(analog mica teormea Fermat) daca p este prim si a elem. al lui Z_p at. a^p-1 = 1
daca |G|= p si p prim at. G este ciclic
daca G si H sunt grupuri de ord. p cu p prim at. G ≈ H
clase de izomorfism: se spune ca sunt k clase de izomorfism ale grupurilor de ordin n daca ∃ k grupuri G₁, G₂, ..., G_k ai
G_i si G_j nu sunt izomorfe ptr i ≠ j
∀ grup de ordin n este izomorf cu unul din grupurile G_i
produsul direct: daca G₁, G₂, ..., G_n sunt grupuri, se defineste relatia binara * : G₁ x G₂ x ... x G_n → G₁ x G₂ x ... x G_n ai a_i*b_i este relatia din grupul G_i
T(fundamentala a grupurilor finite abeliene): daca G este un grup finit abelian cu |G| ≧ 2 at. G ≈ Z_p₁^n₁ x Z_p₂^n₂ ... Z_{p_s^n_s} unde p_i este prim si n_i este intreg pozitiv
inel: un inel este o tripleta ordonata (R, +, .) unde R este o multime iar + si . sunt relatii binare pe R care satisfac urmatoarele:
(R,+) grup abelian, 0 este elem. neutru
. este asociativa
a.(b+c) = a.b + a.c
(b+c).a = b.a + c.a
inel cu elem neutru: un inel (R, +, .) cu element neutru, 1, fata de .
inel comutativ: un inel (R, +, .) cu . comutativa
domeniu de integritate: un inel (R, +, .) cu proprietatile
. comutativa
∃ 1, 1 ≠ 0
nu are divizori ai lui 0: a, b ∈ R si a.b=0 at. a =0 sau b = 0
camp: un inel (R, +, .) cu proprietatile
. comutativa
∃ 1, 1 ≠ 0
∀ x ∈ R si x ≠ 0 at. ∃ y ∈ R ai x.y = 1
caracteristica unui camp: caracteristica unui camp este 0 daca Σ^m₁ 1 ≠ 0, ∀ m intreg pozitiv; altfel caracteristica este cel mai mic intreg pozitiv m ai Σ^m₁ 1 = 0
element unitate: fie un inel (R, +, .) cu elem. neutru fata de ., 1. Un element a ∈ R se numeste unitate a lui R daca este inversabil fata de .
se noteaza cu U(R) multimea unitatilor lui R
grupul unitatilor: (U(R), .) este grup
aⁿ: (R, +, .) inel, a ∈ R, n ∈ N at a¹ = a si aⁿ = a . a . a ... a
(R, +, .) inel cu 1 , a ∈ R, a unitate at a⁰ = a , a^-1 este inversul prin . si a^-n = ( a^-1 )ⁿ
T: (R, +, .) camp ⇒ (R, +, .) domeniu de integritate
T: (Z_n, ⊕, ⊙) camp ⇔ (Z_n, ⊕, ⊙) domeniu de integritate
(Z_n, ⊕, ⊙) camp ⇔ n este prim
homomorfism, izomorfism de inele: fie (R, +, .) si (S, *, #) doua inele. O functie f : R → S se numeste homomorfism daca ∀ a, b ∈ R
f(a . b) = f(a) * f(b)
f(a+b) = f(a) # f(b)
daca f este bijectiva se numeste izomorfism si se spune ca R si S sunt izomorfe si se noteaza R ≈ S
subinel, subcamp: fie S ⊂ R, (S,+,.) este subinel al inelului (R,+,.) daca
0 ∈ S
daca a ∈ S at -a ∈ S
daca a, b ∈ S at. a+b ∈ S si a . b ∈ S
daca (R, +, .) este camp , (S, +, .) este subcamp daca sunt indeplinite si
1 ∈ S
daca a ∈ S si a ≠ 0 at a^-1 ∈ S

ELEMENTARY ABSTRACT ALGEBRA

DES - sumar

2006-01-04T10:21:00.000+02:00

cifru bloc iterat: e_{K_i} : { 0 , 1 }^K_i x { 0 , 1}^l
cifru Feistel: este un cifru bloc iterat care cripteaza un mesaj in clar de lungime 2l, in biti, (L₀ , R₀) in mesajul cifrat (L_t , R_t) pentru care functia de tur este e_{K_i} cu (L_i , R_i) = e_{K_i} (L_i-1 , R_i-1) unde:

L_i = R_i-1

R_i = L_i-1 ⊕ f(R_i-1 , K_i)
DES: este un cifru Feistel pentru care l = 32, k=56, t=16

cheia K are o lungime de 64 biti la care pozitiile 8, 16, 24 .., 64 pot fi folosite pentru paritate; cheia de runda K_i are o lungime de 48 biti

L_i = R_i-1

R_i = L_i-1 ⊕ f(R_i-1 , K_i)

unde f(R_i-1 , K_i) = P ( S ( E ( R_i-1) ⊕ K_i ) ) cu E o permutare,fixata, de expansiune de la 32 la 48 biti, P o lata permutare fixata pe 32 biti

algoritm generare chei

din cheia K se elimina bitii de paritate; se aplica permutarea PC1

57 49 41 33 25 17 9

1 58 50 42 34 26 18

10 2 59 51 43 35 27

19 11 3 60 52 44 36

63 55 47 39 31 23 15

7 62 54 46 38 30 22

14 6 61 53 45 37 29

21 13 5 28 20 12 4

rezultand doua secvente de 28 biti ( C₀ , D₀)

pentru fiecare tur K_i rezulta prin aplicarea permutarii PC2

14 17 11 24 1 5

3 28 15 6 21 10

23 19 12 4 26 8

16 7 27 20 13 2

41 52 31 37 47 55

30 40 51 45 33 48

44 49 39 56 34 53

46 42 50 36 29 32

asupra lui ( C_i , D_i) unde C_i si D_i se obtin din C_i-1 , D_i-1 prin alunecare stanga cu o pozitie pentru tururile 1,2, 9, 16 sau cu doua pozitii pentru celelate tururi

algoritm criptare

blocului de text in clar i se aplica permutarea IC

58 50 42 34 26 18 10 2

60 52 44 36 28 20 12 4

62 54 46 38 30 22 14 6

64 56 48 40 32 24 16 8

57 49 41 33 25 17 9 1

59 51 43 35 27 19 11 3

61 53 45 37 29 21 13 5

63 55 47 39 31 23 15 7

rezultand secventele de 32 de biti ( L₀ , R₀ )

pentru fiecare tur i se calculeaza L_i = R_i-1 si R_i = L_i-1 ⊕ f(R_i-1 , K_i) unde f(R_i-1 , K_i) se caluleza astfel:

se expandeaza R_i-1 de la 32 biti la 48 biti, E(R_i-1) unde E este data de

32 1 2 3 4 5

4 5 6 7 8 9

8 9 10 11 12 13

12 13 14 15 16 17

16 17 18 19 20 21

20 21 22 23 24 25

24 25 26 27 28 29

28 29 30 31 32 1

se face un XOR intre E(R_i-1) si K_i rezultand 8 secvente de 6 biti ( B₁ , ..., B₈)

fiecarei secvente B_j i se aplica maparea S_j; pentru B_j = b₁b₂ .. b₆ se calculeaza randul r = 2 b₁ + b₆ si coloana c = b₂b₃b₄b₅; cu r si c astfel calculati se obtin maparile conform cu tabelele
S₁

r/c 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7

1 0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8

2 4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0

3 15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13

S₂

r/c 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 15 1 8 14 6 11 3 4 9 7 2 13 12 0 5 10

1 3 13 4 7 15 2 8 14 12 0 1 10 6 9 11 5

2 0 14 7 11 10 4 13 1 5 8 12 6 9 3 2 15

3 13 8 10 1 3 15 4 2 11 6 7 12 0 5 14 9

S₃

r/c 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 10 0 9 14 6 3 15 5 1 13 12 7 11 4 2 8

1 13 7 0 9 3 4 6 10 2 8 5 14 12 11 15 1

2 13 6 4 9 8 15 3 0 11 1 2 12 5 10 14 7

3 1 10 13 0 6 9 8 7 4 15 14 3 11 5 2 12

S₄

r/c 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 7 13 14 3 0 6 9 10 1 2 8 5 11 12 4 15

1 13 8 11 5 6 15 0 3 4 7 2 12 1 10 14 9

2 10 6 9 0 12 11 7 13 15 1 3 14 5 2 8 4

3 3 15 0 6 10 1 13 8 9 4 5 11 12 7 2 14

S₅

r/c 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 2 12 4 1 7 10 11 6 8 5 3 15 13 0 14 9

1 14 11 2 12 4 7 13 1 5 0 15 10 3 9 8 6

2 4 2 1 11 10 13 7 8 15 9 12 5 6 3 0 14

3 11 8 12 7 1 14 2 13 6 15 0 9 10 4 5 3

S₆

r/c 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 12 1 10 15 9 2 6 8 0 13 3 4 14 7 5 11

1 10 15 4 2 7 12 9 5 6 1 13 14 0 11 3 8

2 9 14 15 5 2 8 12 3 7 0 4 10 1 13 11 6

3 4 3 2 12 9 5 15 10 11 14 1 7 6 0 8 13

S₇

r/c 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 4 11 2 14 15 0 8 13 3 12 9 7 5 10 6 1

1 13 0 11 7 4 9 1 10 14 3 5 12 2 15 8 6

2 1 4 11 13 12 3 7 14 10 15 6 8 0 5 9 2

3 6 11 13 8 1 4 10 7 9 5 0 15 14 2 3 12

S₈

r/c 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0 13 2 8 4 6 15 11 1 10 9 3 14 5 0 12 7

1 1 15 13 8 10 3 7 4 12 5 6 11 0 14 9 2

2 7 11 4 1 9 12 14 2 0 6 10 13 15 3 5 8

3 2 1 14 7 4 10 8 13 15 12 9 0 3 5 6 11

secventei obtinute prin concatenarea celor 8 secvente de 4 biti S_j( B_j ) i se aplica permutarea P

16 7 20 21

29 12 28 17

1 15 23 26

5 18 31 10

2 8 24 14

32 27 3 9

19 13 30 6

22 11 4 25

secventei de 64 biti ( R₁₆ , L₁₆) i se aplica inversa permutarii IC

algoritm decriptarare
se foloseste algoritmul de criptare cu cheile in ordine inversa

FIPS-46-3

Moduri de operare cifruri bloc

2005-12-19T17:52:00.000+02:00

Criterii de evaluare cifruri bloc si moduri de operare
- nivelul de securitate estimat
  increderea intr-un cifru creste daca acesta a constituit subiect de criptanaliza pentru o perioada indelungata de timp. Cantitatea de text cifrat necesara pentru realizarea de atacuri poate uneori depasi distanta de unicitate a unui cifru care estimeaza cantitatea de text cifrat necesara pentru regasirea cheii
- marimea cheii
  lungimea in biti a cheii defineste o limita superioara a securitatii unui cifru (la cautarea completa) dar o lungime mai mare a cheii implica costuri aditionale
- volumul
  este legat de complexitatea maparii criptografice si de modul de implementare pe o anumita platforma
- marimea blocului
  este un compromis intre o lungime cat mai mare (motive de securitate) si o lungime cat mai mica (motive de implementare)
- expandarea datelor
  nu este de dorit a se realiza expandarea; apare la substitutia homofonica si la tehnicile pseudoaleatoare
- propagarea erorii
  biti eronati in textul cifrat au efecte diverse la decriptare
Moduri de operare pentru confidentialitate
- modul ECB (electronic codebook)
  - algoritm
    intrarea consta in blocurile textului in clar p₁,p₂,...,p_t (blocuri de lungime n) si iesirea in blocurile textului cifrat c₁,c₂,...,c_t (blocuri de lungime n) unde c_i = e_k ( p_i ) si p_i = d_k ( c_i ) cu 1 ≦ i ≦ t, p_i ∈ P, c_i ∈ C, k ∈ K
  - proprietati
    un bloc de text in clar se cripteaza intotdeauna in acelasi bloc de text criptat, pentru aceeasi cheie
    blocurile de text in clar se cripteaza independent de alte blocuri de text in clar; reordonarea blocurilor de text criptata conduce la o reordonare a blocurilor de text in clar
    erorile de bit intr-un bloc de text criptata afecteaza numai decriptarea acelui bloc
  - observatii
    este recomandat pentru mesaje ce constau intr-un singur bloc; eventual, blocurile de text clar pot fi completate cu secvente aleatoare
- modul CBC (cipher-block chaining)
  - algoritm
    intrarea consta in blocurile textului in clar p₁,p₂,...,p_t (blocuri de lungime n) si iesirea in blocurile textului cifrat c₁,c₂,...,c_t (blocuri de lungime n) unde c_i = e_k ( c_i-1 ⊕ p_i ) si p_i = c_i-1 ⊕ d_k ( c_i ) cu 1 ≦ i ≦ t, p_i ∈ P, c_i ∈ C, k ∈ K, c₀ se obtine dintr-un vector de initializare de lungime n biti
  - proprietati
    un bloc de text in clar se cripteaza intotdeauna in acelasi bloc de text criptat, pentru aceeasi cheie si acelasi vector de initializare
    deoarece un bloc de text criptat depinde de blocurile criptate anterioare, reordonarea blocurilor criptate afecteaza decriptarea corecta
    erorile de bit afecteaza decriptararea blocurilor urmatoare
    acest mod este autosincronizabil in sensul ca o eroare in blocul criptat i nu afecteaza decriptarea blocului i+2 daca blocul i+1 nu are erori
  - observatii
    nu se poate folosi in aplicatiile ce utilizeaza accesul aleator scriere/citire la date criptate deoarece o modificare intr-unul din blocurile textului in clar afecteaza criptarea in toate blocrile ulterioare criptate
    pierderile de bit afecteaza delimitarea blocurilor criptate
    se recomanda utilizarea unui vector de initializare secret; mecanismul de criptare garanteaza numai confidentialitatea nu si integritatea
- modul CFB (cipher feedback)
  aplicatiile ar putea necesita criptarea unor blocuri de text in clar de lungime r, 1 ≦ r ≦ n ( in mod tipic r =1 sau r = 8)
  - algoritm
    intrarea consta in blocurile textului in clar p₁,p₂,...,p_u (blocuri de lungime r) si iesirea in blocurile textului cifrat c₁,c₂,...,c_u (blocuri de lungime r) unde c_i = p_i ⊕ s_i si p_i = c_i ⊕ s_i cu 1 ≦ i ≦ u, p_i ∈ P, c_i ∈ C, k ∈ K si secventa
    ( I₁ se obtine dintr-un vector de initializare de lungime n biti)
    O_i = e_k ( I_i )
    s_i sunt cei mai semnificativi r biti din O_i
    I_i+1 = 2^rI_i + c_i mod 2ⁿ
  - proprietati
    un bloc de text in clar se cripteaza intotdeauna in acelasi bloc de text criptat, pentru aceeasi cheie si acelasi vector de initializare
    deoarece un bloc de text criptat depinde de blocurile criptate anterioare, reordonarea blocurilor criptate afecteaza decriptarea corecta; decriptarea corecta necesita [n/r] blocuri anterioare criptate corecte
    erorile de bit afecteaza decriptararea urmatoarelor [n/r] blocuri (pana ce blocul eronat a fost curatat din registrul de alunecare)
    acest mod este autosincronizabil dar dupa [n/r] blocuri
    pentru r < n, volumul scade cu un factor n/r comaparat cu modul CBC
  - observatii
    nu este neaparat necesar ca vectorul de initializare sa fie secret
    deoarece atat la criptare cat si la decriptare se foloseste e_k, acest mod nu se foloseste decat daca e nu este un algoritm cu cheie publica
- modul OFB (output feedback)
  - algoritm
    OFB cu feedback complet
    intrarea consta in blocurile textului in clar p₁,p₂,...,p_u (blocuri de lungime r) si iesirea in blocurile textului cifrat c₁,c₂,...,c_u (blocuri de lungime r) unde c_i = p_i ⊕ s_i si p_i = c_i ⊕ s_i cu 1 ≦ i ≦ u, p_i ∈ P, c_i ∈ C, k ∈ K si secventa
    ( I₁ se obtine dintr-un vector de initializare de lungime n biti)
    O_i = e_k ( I_i )
    s_i sunt cei mai semnificativi r biti din O_i
    I_i+1 = O_i
    OFB cu feedback pe r biti
    intrarea consta in blocurile textului in clar p₁,p₂,...,p_u (blocuri de lungime r) si iesirea in blocurile textului cifrat c₁,c₂,...,c_u (blocuri de lungime r) unde c_i = p_i ⊕ s_i si p_i = c_i ⊕ s_i cu 1 ≦ i ≦ u, p_i ∈ P, c_i ∈ C, k ∈ K si secventa
    ( I₁ se obtine dintr-un vector de initializare de lungime n biti)
    O_i = e_k ( I_i )
    s_i sunt cei mai semnificativi r biti din O_i
    I_i+1 = 2^rI_i + s_i mod 2ⁿ
  - proprietati
    un bloc de text in clar se cripteaza intotdeauna in acelasi bloc de text criptat, pentru aceeasi cheie si acelasi vector de initializare
    fluxul de chei este independent de textul in clar
    unul sau mai multi biti eronati in blocul c_i afecteaza numai decriptarea blocului respectiv
    nu se autosincronizeaza la pierderea bitilor din blocuri cifrate
    pentru r < n, volumul scade cu un factor n/r comaparat cu modul CBC; fluxul de chei poate fi calculat avnd cheia si secventa de initializare
  - observatii
    nu este neaparat necesar ca vectorul de initializare sa fie secret, dar acesta trebuie modificat la reutilizarea unei chei
    deoarece atat la criptare cat si la decriptare se foloseste e_k, acest mod nu se foloseste decat daca e nu este un algoritm cu cheie publica
- modul CTR (counter mode)
  - algoritm: este o simplificare a OFB la care I_i+1 = I_i+1
  - proprietati: decriptarea lui c_i+1 nu necesita decriptarea lui c_i astfel ca accesul este secvential
  - observatii
    
    pentru toate mesajele criptate cu aceeasi cheie, contoarele trebuie sa fie diferite
Moduri de operare pentru autentificare date
Moduri de operare pentru autentificare date si confidentialitate

FIPS81 SP800-38A SP800-38C

Cativa algoritmi teoria numerelor

2005-12-02T14:04:00.000+02:00

cmmdc/inversul mod: Euclid
Functia Euclid(a,b)
if b = 0 return a
return(Euclid(b; a(modb)))
end Euclid.

Euclid extins
Functia Euclid-Extins(a,b)
if b = 0 return (a; 1; 0)
a = bk + r.
(d; x; y) = Euclid-Extins(b; r)
return(d; y; x - ky )
end Euclid-Extins

Euclid extins aplicat intregilor pe n biti ruleaza in O(n³)
Euclid extins aplicat polinoamelor de grad n, peste orice camp, ruleaza in O(n²)
congruente liniare de o variabila transformarile in ambele sensuri intre reprezentarile x mod N si x ≡ a_i mod p_i unde cmmdc(p_i, p_j) = 1 ptr i ≠ j , i, j ∈ {1, 2, ..., r} si Π_i=1^r p_i ( din teorema chineza a resturilor): de la x mod N catre x ≡ a_i mod p_i este trivial
de la x ≡ a_i mod p_i catre x mod N
N = Π_i=1^r p_i
N_i = n / p_i
N_iN_i^-1 ≡ 1 ( mod p_i ); N_i^-1 se calculeaza prin Euclid extins
x = Σ_i=1^r a_iN_iN^-1_i
ruleaza in O(n³)
teste primalitate: testul Miller-Rabin
se testeaza numarul n ∈ N cu n -1 = 2^s t, unde t este impar si s ≧ 1; se alege aleator a
se calculeaza u₀ = a^t ( mod n)
se calculeaza u_i+1 = u²_i ( mod n)

se declara n probabil prim daca u₀ = 1 sau ∃ i ai u_i = -1
Testul Miller-Rabin repetat de k ori declara intotdeauna un prim ca probabil prim. Un numar compozit este declarat probabil prim cu o probabilitate de cel mutl 2^-k
ruleaza in O(k n³)
descompunerea in factori primi: metoda ρ a lui Pollard
se alege x₀ ∈ Z_n
se defineste secventa cu relatia de recurenta x_i+1 = x_i+1² + 1 mod n
se calculeaza cmmdc(x_2i - x_i , n) si se opreste calculul daca d > 1
se testeaza primalitatea factorului gasit anterior
din practica, O(n^1/4)
logaritmul discret: logaritmul discret al lui y in baza g modulo p este x ai g^x ≡ y mod p unde p este prim si g ∈ U_p
algoritmul pas pitic/pas gigant
se calculeaza a ca parte intreaga din p^1/2
se construieste lista: 1, g^a, g^2a, g^3a, ,,,, g^a²
se construieste lista y, yg, yg², yg³, ..., , yg^a-1
se cauta numarul z care apare in ambele liste
z ≡ yg^k ≡ g^la mod p
y ≡ g^la-k ≡ g^x mod p
x ≡ la-k mod ( p - 1 )
ruleaza in O( (log p)² p^1/2)

Algoritmi avansati, Johan Hastad

Memento teoria numerelor

2005-11-29T13:54:00.000+02:00

divizibilitate: d|n, d divide n (d este un divizor al lui n, d este un factor al lui n, n este un multiplu al lui d), d, n ∈ Z ⇔ ∃ k ∈ Z ai n = d * k
teorema impartirii: a ∈ Z, b ∈ Z^* at ∃ q, r ∈ Z, unici, ai a = b * q + r si 0 ≦ r < b; a ∈ Z, b ≠ 0 at ∃ q, r ∈ Z, unici, ai a = b * q + r si 0 ≦ r < | b |
modulo: a mod b = { b / a ∈ Z, b ∈ Z^*, a = b * q + r }
cmmdc: cmmdc(a, b) ⇔ a, b ∈ Z^*, D = {d | d|a ∧ d|b}, cmmdc(a, b) = sup D
proprietati: ∀ a, b ∈ Z^*, ∃ cmmdc(a, b) si 0 < cmmdc(a, b) ≦ min ( | a |, | b |)
∀ a ∈ Z^* at cmmmdc(a, 0) = 0
∀ a, b ∈ Z⁺, cmmdc(a, b) = cmmdc (b, r) unde a = b * q +r
Lema Bezout: ∀ a, b ∈ Z ∃ s, t ai cmmdc(a, b) = s * a + t * b
numar prim: p ∈ Z, p ≧ 2, se numeste prim ⇔ D = { d / d | p} contine numai pe 1 si pe p (altfel se numeste numar compozit)
T: n ∈ Z⁺ este compozit ⇔ ∃ a, b , 1 < a < n, 1 < b < n ai n = a * b
∀ n > 1, ∃ p, un numar prim, ai p | n
(Euclid) exista un numar infinit de numere prime
daca n > 1, este un numar compozit at. ∃ p, un numar prim, ai p | n si p ≦ n^1/2
π ( x ): reprezinta cardinalul multimiii numerelor prime mai mici decat x ∈ R⁺
T: π ( x ) ~ x / ln ( x ), x ∈ R⁺
Teorema fundamentala a aritmeticii (descompunerea in factori primi): ∀ n intreg, n > 1, poate fi scris sub forma n = p₁p₂...p_s unde s este un intreg pozitiv si p₁p₂...p_s sunt prime ce satisfac relatia p₁≦p₂≦...≦p_s
descompunerea in factori primi exista si este unica
daca a si b sunt doua numere supraunitare cu descompunerile in factori primi a = p₁^a₁p₂^a₂...p_k^a_k si b = p₁^b₁p₂^b₂...p_k^b_k at. cmmdc( a , b ) = p₁^{min ( a₁ , b₁ )}p₂^{min ( a₂ , b₂ )}...p_k^{min ( a_k , b_k )}
numere relativ prime: a, b sunt relativ prime ⇔ cmmdc ( a , b ) = 1
T: fie a > 1 si n > 1
aⁿ-1 este prim ⇒ a = 2 si n este prim
aⁿ+1 este prim ⇒ a este impar si ∃ k > 1 ai n = 2^k
numere Mersenne: Daca un numar este de forma M_n = 2ⁿ-1 se numeste numar Mersenne. Daca M_n este prim se numeste prim Mersenne
numere Fermat: Daca un numar este de forma F_n = 2^2ⁿ-1 se numeste numar Fermat. Daca F_n este prim se numeste prim Fermat
T: Daca M_n este prim at. n este prim
(Lucas-Lehmer)
functiile σ si τ: fie n > 0; se noteaza
τ ( n ) cardinalul multimii formate de divizorii pozitiv ai lui n
σ ( n ) suma divizorilor pozitiv ai lui n
T: fie descompunerea in factori a lui n = p₁^e₁p₂^e₂...p_r^e_r unde r ≧ 1 , p₁≦p₂≦...≦p_r sunt prime si e_i ≧ 0, ∀ i ∈ { 1 , 2, ... , r }. At.
τ ( n ) = ( e₁ + 1 )( e₂ + 1 ) ... ( e_r + 1 )
σ ( n ) = ( p₁^{e₁ + 1} - 1 ) / ( p₁ - 1) ( p₂^{e₂ + 1} - 1 ) / ( p₂ - 1) ... ( p_r^{e_r + 1} - 1 ) / ( p_r - 1)
numere perfecte: se noteaza σ^*( n ) suma divizorilor pozitivi mai mici ca n, ai lui n
ptr n ≧ 2, σ^*( n ) = σ( n ) -n
un numar este perfect daca σ^*( n ) = n
congruente: a congruent cu b modulo m
a ≡ b (mod m) ⇔ ptr m ≧ 0, m | a - b

m > 0, ∀ a, b : a ≡ b (mod m) ⇔ a mod m = b mod m ptr m ≧

proprietati relatie congruenta
(reflexivitate) a ≡ a ( mod m)
(simetrie) a ≡ b (mod m) ⇒ b ≡ a (mod m)
(tranzitivitate) a ≡ b (mod m) si b ≡ c (mod m) ⇒ a ≡ c (mod m)

element invers
daca cmmdc( a , m ) = 1 at ∃ a', 0 < a' < m , unic, ai aa' ≡ (mod m)

T operatii
a ≡ b ( mod m) si a ≡ b ( mod m) ⇒
a ± b ≡ c ± d ( mod m)
ac ≡ bd ( mod m)
aⁿ ≡ bⁿ ( mod m ) ∀ n ≧ 1
f ( a ) ≡ f ( b ) , ∀ f ( x) , polinom cu coeficienti intregi

T
ptr c > 0 , m > 0 : a ≡ b ( mod m) ⇔ ca ≡ cb ( mod cm)
ptr. m > 0 si d = cmmdc ( c , m) : ca ≡ cb ( mod m) ⇒ a ≡ b ( mod m/d)
m > 0 , a ≡ b ( mod m) ⇒ cmmdc ( a, m) = cmmdc ( b , m)
clase de resturi: clasa de resturi a modulo m
pt. m > o fixat si ptr a intreg se defineste [a] = { x / x ≡ a ( mod m) }
ptr. m > 0: [ a ] = { mq + a / q ∈ Z }
ptr. m > 0 : [ a ] = [ b ] ⇔ a ≡ b ( mod m)
ptr. m > 0, ∀ a, ∃ r, 0 ≦ r < m, unic, ai [ a ] = [ r ]
ptr. m > 0 sunt exact m clase distincte de resturi, [ 0 ] , [ 1 ] , ... , [ m - 1 ]
sisteme de resturi: m > 0
inelul intregilor modulo m
Z_m = { [ a ] / a ∈ Z}
sistem complet de resturi modulo m
multimea de intregi { a₁ , a₂ , ... , a_m } se numeste sistem complet de resturi modulo m daca Z_m = { [ a₁ ] , [ a₂ ] , ... , [ a_m ] }
daca m = 2k at. {0, 1, 2, ..., k-1, k, -(k-1), ..., -2, -1} este un sistem complet de resturi modulo m
daca m = 2k + 1 at. {0, 1, 2, ..., k, -k, ..., -2, -1} este un sistem complet de resturi modulo m
adunarea si inmultirea in Z_m
fie [ a ], [ b ] ∈ Z_m, se definesc: [ a ] + [ b ] = [ a + b } si [ a ][ b ] = [ ab ]
J_m = {0, 1, ... m - 1} cu operatiile a ⊕ b = ( a + b) mod m si a ⊙ b = ( ab ) mod m formeaza un inel izomorf cu Z_m
o clasa de resturi [ a ] ∈ Z_m este unitara daca nu este inversabila ⇔ cmmdc ( a , m) = 1
grupul unitatilor
U_m = { [ i ] / 1 ≦ i ≦ m si cmmmdc( i , m) = 1} impreuna cu inmultirea (din Z_m) formeaza un grup abelian
daca p este prim, at. ∃ a ∈ U_p ai U_p = <a>
daca n ≧ 2 , at. ∃ a ∈ U_p ai U_p = <a> ⇔ a este de froma 2, 4, p^k, 2 p ^k unde p ≧ 2, p este prim si k ∈ N
functia φ Euler
ordinul lui U_m
proprietati φ Euler
ptr. a > 0, b > 0 si cmmdc ( a , b ) = 1 : φ( ab ) = φ( a )φ( b )
ptr. p, prim, si n > 0 : φ( pⁿ ) = pⁿ - p^n-1
ptr. p₁, p₂, ..., p_k, prime distincte, si n₁, n₂, ..., n_k, intregi pozitivi : φ(p₁^n₁ p₂^n₂ ... p_k^n_k) = ( p₁^n₁ - p₁^n₁-1 ) ... ( p_k^n_k - p_k^n_k-1 )
T
fie a, b ∈ Z⁺, cmmdc( a , b ) = 1 si n = ab. Se defineste f ( [ x ]_n ) = ( [ x ]_a , [ x ]_b )
(teorema chineza a resturilor) f : Z_n → Z_a x Z_b este bijectiva
f : U_n → U_a x U_b este bijectiva
teste primalitate: mica teorma a lui Fermat
daca p este prim si a, cmmdc( a , p) = 1 at. a^p-1 ≡ 1 ( mod p)
teorema lui Euler
ptr. m > 0 si a, cmmdc( a , m ) = 1 : a^φ(m) ≡ 1 ( mod m )
a^p ≡ a ( mod p), ∀ a si p prim
ptr. m ≧ 2, ∀ a, 1 ≦ a ≦ m -1, a^m-1 ≡ 1 ( mod m) ⇒ m prim
reprezentarea lui n in baza b
ptr. b ≧ 2, n > 0 , n = [a_k, a_k-1, ..., a₁, a₀]_b este reprezentarea in baza b a lui n ⇔ ∃ k ≧ 0 ai n = a_kb^k + a_k-1b^k-1 + ... + a₁b + a₀ unde a_i ∈ {0, 1, ..., b-1}, i ∈ {0, 1, ..., k}
reprezentarea este unica
metoda binara pentru calculul lui xⁿ, x ∈ R, n ∈ Z⁺
se gaseste reprezentarea binara n = [ a_r , ... , a₁ ,a₀ ]₂
se calculeaza puterile x² , x^2² , ... , x^{2^r}
se calculeaza produsul xⁿ = x^{a_r2^r} x^{a_r-12^r-1} x^a₁2 x^a₀
metoda binara pentru calculul lui xⁿ ( mod m) , x ∈ R, n ∈ Z⁺
se gaseste reprezentarea binara n = [ a_r , ... , a₁ ,a₀ ]₂
se calculeaza redusele modulo m ale puterilor x² , x^2² , ... , x^{2^r} , m₁ = x² mod m , m₂ = x^2² mod m , ... , m_r = x^{2^r} mod m
se calculeaza produsul xⁿ mod m = m_rm_r-1 ... m₁ m₀

Introducere in teoria numerelor, Edwin Clark

Functii cu trapa

2005-11-28T15:39:00.000+02:00

functie cu trapa: f : N → R este o functie cu trapa ⇔
f este o functie cu sens unic
∃ p, o functie polinomiala, si ∃ A, un algoritm PTP ai
∀ k, ∃ t_k ∈ {0, 1}^* cu | t_k | ≦ p ( k )
∀ x ∈ {0, 1}^*, A( f ( x) , t_k) = y ai f ( y ) = f ( x)
familie de functii puternice cu trapa si cu sens unic: F = { f_i : D_i → D_i }_i∈I, unde i ∈ I, ,multimea indicilor, este o familie de functii puternice cu trapa si cu sens unic daca:
∃ S₁, o MTP, si p, o functie polinomiala, ai ( i , t_i ) ← S₁ ( x ∈ {0, 1}^k ), i ∈ {0, 1}^k ∩ I si | t_i | < p ( k ); t_i se numeste trapa pentru i
∃ S₂, o MTP, ai x ← S₂ ( i ∈ I ), x∈ D_i
∃ A₁, o MTP, ai A₁ ( i , x ) = f_i( x ), unde i ∈ I, x ∈ D_i
∀ A, un algoritm PTP, ∃ m_A, o functie neglijabila, ai P [ f_i ( z ) = y ; x ∈ D_i; i ∈ I ; y ← f_i ( x ) ; z ← A ( i , y ) ] ≦ m_A pentru k suficient de mare

Functii cu sens unic

2005-11-25T16:46:00.000+02:00

functie neglijabila: f : N → R este neglijabila ⇔ ∀ c > 0, ∃ k_c, ai f(k) < k^-c, ∀ k > k_c
functie puternica cu sens unic: f : {0, 1}^* → {0, 1}^* este puternica, cu sens unic ⇔:
∃ A, un algoritm PTP (probabilstic de timp polinomial), care obtine y = f(x), pentru x dat
∀ A, ∃ m_A, o functie neglijabila, ai P [ f ( z ) = y ; x ∈ {0, 1}^* ; y ← f ( x ) ; z ← A ( y ) ] ≦ m_A pentru k suficient de mare
Garantia este probilista, distributia de probabilitate este pe intreg domeniul lui f; nu se cere sa determine x ci sa se gaseasca o inversa ptr y; algoritmul primeste ca intrare f ( x ) si ruleaza in timp polinomial pe |x|
functie slaba cu sens unic: f : {0, 1}^* → {0, 1}^* este slaba, cu sens unic ⇔:
∃ A, un algoritm PTP, care obtine y = f(x), pentru x dat
∀ A, ∃ Q, o functie polinomiala, ai P [ f ( z ) ≠ y ; x ∈ {0, 1}^* ; y ← f ( x ) ; z ← A ( y ) ] ≧ m_A pentru k suficient de mare
Diferenta intre cele tipuri de functii este ca o functie slaba cu sens unic este greu de inversat pe o fractiune neglijabila a domeniului in timp ce o functie puternica cu sens unic este greu de inversat pe tot domeniul mai putin o fractiune neglijabila
∃ functii slabe ⇔ ∃ functii puternice
familie de functii puternice cu sens unic: F = { f_i : D_i → R_i }_i∈I, unde i ∈ I, ,multimea indicilor, este o familie de functii puternice cu sens unic daca:
∃ S₁, un algoritm PTP, ai i ← S₁ ( x ∈ {0, 1}^k ), i∈ {0, 1}^k ∩ I
∃ S₂, un algoritm PTP, ai x ← S₂ ( i ∈ I ), x∈ D_i
∃ A₁, un algoritm PTP, ai A₁ ( i , x ) = f_i( x ), unde i ∈ I, x ∈ D_i
∀ A, un algoritm PTP, ∃ m_A, o functie neglijabila, ai P [ f_i ( z ) = y ; x ∈ D_i; i ∈ I ; y ← f_i ( x ) ; z ← A ( i , y ) ] ≦ m_A pentru k suficient de mare

Secvente pseudoaleatoare

2005-11-25T14:13:00.000+02:00

Generator bit pseudo-aleator (GBPSA)

Este un algoritm determinist care porneste de la o secventa binara aleatoare de lungime k, numita cheie de generare, si produce o secventa binara de lungime l>>k, numita secventa de biti pseudo-aleatori
Un GBPSA este un program determinist de timp polinomial G:{0, 1}^k → {0, 1}^l care satisface:

l > k
distributia de probabilitate G_l se obtine din distributia normala U_k astfel: y=G(x), y ∈ G_l, x ∈ U_k

Teste in timp polinomial

Un generator bit pseudo-aleator trece toate testele statistice in timp polinomal daca un algoritm de timp polinomial nu poate face distinctia intre o secventa de la iesirea generatorului de bit pseudo-aleator si o secventa aleatoare de bit cu o probabilitate semnificativ mai mare ca 1/2
Fie X_n si Y_n doua distributii de probabilitate pe {0, 1}ⁿ. {X_n} este indistinctibila in timp polinomial de {Y_n} daca ∀ MTP, A, ∀ polinom Q, ∃ n>n₀ ai | Pr_{t∈X_n} (A(t)=1) - Pr_{t∈Y_n} (A(t)=1) | < 1/Q(n)
Pentru distributia uniforma de probabilitate U_n, ∀ a ∈ {0, 1}ⁿ, Pr_{x∈U_n} [x=a] = 1/ 2ⁿ

Testul bitului urmator

Un generator bit pseudo-aleator trece testul bitului urmator daca nu exista un algoritm de timp polinomial care sa poata prezice bitul "l+1" cu o probabilitate semnificativ mai mare ca 1/2, in baza primilor "l" biti ai unei secventa de la iesirea generatorului de bit pseudo-aleator
Un generator de bit pseudo-laeator trece testul bitului urmator ⇔ generatorul de bit pseudo-aleator trece testele de timp polinomial

Generator sigur criptografic de bit pseudo-aleator

Este un GBPSA care trece testul bitului urmator, posibil in niste ipoteze matematice plauzibile, dar nedemonstrate

Clase de complexitate

2005-11-17T14:57:00.000+02:00

Limite
Clase
1. Limbaje
2. Functii

Modele calcul - automate

2005-11-16T16:11:00.000+02:00

Clasificare

Clasificarea Chomsky	Gramatica	Limbajul	Automatul minimal	Forma normala
tip 0	fara restrictie	recursiv enumerabil	MTN	-
-	fara restrictie	recursiv	decidor	-
tip 1	dependenta de context	dependent de context	marginit liniar	KURODA
tip 2	independenta de context	independent de context	push down	CHOMSKY, GREIBACH
tip 3	regulara	regular	finit	-

Gramatici si limbaje

O multime finita si nevida, Σ, se numeste alfabet iar elementele se numesc simboluri
O succesiune de simboluri se numeste secventa si o submultime ordonata a unei secvente se numeste subsecventa
Numarul de simboluri care formeaza o secventa s se numeste lungimea secventei si se noteaza |s|
Multimea secventelor peste un alfabet Σ se noteaza Σ^*
(Σ^*, +) este monoid unde "+" este concatenarea si elementul neutru este secventa vida ε
O submultime a lui Σ^* se numeste limbaj iar elementele limbajului se numesc cuvinte
Se numeste gramatica G un cvadruplu (N, Σ, P, s) unde
- N este un alfabet de simboluri neterminale
- Σ este un alfabet de simboluri terminale, N si Σ sunt disjuncte
- P este o multime finita de productii, P⊂ (N∪Σ)^*N(N∪Σ)^* X (N∪Σ)^*
- s este simbolul initial, s∈N
Pe multimea (N∪Σ)^* se definesc relatiile binare
Limbajul L(G) generat de o gramatica G=(N, Σ, P, s) este {v/ v∈ Σ^*, s ⇒^* v}
Clasificarea Chomsky
- Gramaticile de tip 0 nu au nici o restrictie referitoare la forma productiilor
- Gramaticile de tip 1, gramatici dependente de context, au productii de forma αAβ → αγβ unde αβγ ∈ (N∪Σ)^* si A ∈ N iar daca productia s → ε ∈ G atunci s nu apare in mebrul drept al nici unei productii (monotone, necontractante)
- Gramaticile de tip 2, gramatici independente de context, au productii de forma A → α unde A ∈ N si α ∈ (N∪Σ)^*
- Gramaticile de tip 3, gramatici regulare, au productii de forma A → aB sau A → b unde A, B ∈ N si a, b ∈ Σ

Automate

Automate finite
- Automat finit determinist
  Un cvintuplu AFD=(Q, Σ, δ, q₀, F) unde:
  - Q este o multime finita nevida; elementele sale se numesc stari
  - Σ este un alfabet de intrare
  - δ este functia de tranzitie, δ : Q X Σ → Q
  - q₀ este starea initiala, q₀ ∈ Q
  - F este multimea starilor finale, F ⊆ Q
  Daca δ este surjectiva, AFD este total definit
- Automat finit nedeterminist
  Un cvintuplu AFN=(Q, Σ, δ, q₀, F) unde:
  - Q este o multime finita nevida; elementele sale se numesc stari
  - Σ este un alfabet de intrare
  - δ este functia de tranzitie, δ : Q X Σ → P(Q)
  - q₀ este starea initiala, q₀ ∈ Q
  - F este multimea starilor finale, F ⊆ Q
- Tranzitii
  Multimea configuratiilor unui automat este Q X Σ. Pe multimea configuratiilor se definesc urmatoarele relatii binare
  - tranzitia directa, →
    (p, as) → (q, v) ⇔ q = δ(p,a) unde p, q ∈ Q, a ∈ Σ, s ∈ Σ^*
  - k tranzitia, →^k
    (p, s₁) → (q, s₂) ⇔ de la configuratia (p, s₁) se ajunge la configuratia (q, s₂) prin k tranzitii directe
  - + tranzitia, →⁺
    (p, s₁) →⁺ (q, s₂) ⇔ ∃ k > 0 ai (p, s₁) →^k (q, s₂)
  - * tranzitia, →^*
    (p, s₁) →^* (q, s₂) ⇔ p=q, s₁=s₂ sau (p, s₁) →⁺ (q, s₂)
- Limbaj acceptat
  Limbajul acceptat de un automat finit AF = (Q, Σ, δ, q₀, F) este L(AF) = {s / S ∈ Σ, (p, s) →^* (q, ε), q ∈ F }
- Automate echivalente
  - Doua AF sunt echivalente daca accepta acelasi limbaj
  - ∀ AFN, M1, ∃ AFD, M2 ai L(M1) = L(M2)
Automate push down
Un septuplu APD=(Q, Σ, Γ, δ, q₀, Z₀, F) unde:
- Q este o multime finita nevida; elementele sale se numesc stari
- Σ este un alfabet de intrare
- Γ este alfabetul memoriei stiva
- δ este functia de tranzitie, δ : Q x ( Σ ∪ {ε} ) x Γ → P(Q x Γ^*)
- q₀ este starea initiala, q₀ ∈ Q
- Z₀ este simbolul de start al memoriei stiva
- F este multimea starilor finale, F ⊆ Q
Masini Turing
- Masina Turing determinista
  Un septuplu MTD=(Q, Σ, Γ, δ, q₀, B, F) unde:
  - Q este o multime finita nevida; elementele sale se numesc stari
  - Σ este un alfabet de intrare, Σ ⊂ Γ - {B}
  - Γ este alfabetul benzii
  - δ este functia de tranzitie, δ : Q x Γ → Q x Γ x {miscareStanga, miscareDreapta}
  - q₀ este starea initiala, q₀ ∈ Q
  - B este simbolul spatiu, B ∈ Γ
  - F este multimea starilor finale, F ⊆ Q
- Masina Turing nedeterminista
  Un septuplu MTN=(Q, Σ, Γ, δ, q₀, B, F) unde:
  - Q este o multime finita nevida; elementele sale se numesc stari
  - Σ este un alfabet de intrare, Σ ⊂ Γ - {B}
  - Γ este alfabetul benzii
  - δ este functia de tranzitie, δ : Q x Γ → P( Q x Γ x {miscareStanga, miscareDreapta} )
  - q₀ este starea initiala, q₀ ∈ Q
  - B este simbolul spatiu, B ∈ Γ
  - F este multimea starilor finale, F ⊆ Q
- Masina Turing probibilista
  MTP este o MTN pentru care selectia intre valorile functiei de tranzitie se face probabilistic

Secvente aleatoare

2005-11-15T17:05:00.000+02:00

Generator de bit aleator

Dispozitiv sau algoritm care produce o secventa de cifre binare care sunt independente statistic si fara nici o preferinta pentru vreuna dintre cifre

Obs

Dispozitivele folosesc ca sursa de entropie fenomenele fizice. Generarea print-un algoritm presupune exploatarea unui proces specific platformei de calcul. Este indicata utilizarea mai multor surse naturale de etropie, esantionarea acestora, concatenarea si apoi mixarea (ex: printr-o functie dispersie)
Utilizarea in scopuri criptografice a unui generator aleator implica interzicerea accesului adversarului la generator

Teste statistice

Este imposibil sa se demonstreze matematic ca un generator este cu adevarat aleator. Se folosesc teste statistice pentru detectarea eventualelor slabiciuni dar rezultatul trebuie privit ca o dovada probabilistica ca generatorul produce secvente cu anumite proprietati

testul de frecventa (un bit)

se testeaza daca aparitiile cifrelor "0" si "1" sunt aproximativ egale. Variabila aleatoare X=(n₀-n₁)²/n trebuie sa prezinte o distributie de probabilitate χ² cu un grad de libertate daca n>10 (in practica n>>10000)
testul serial (doi biti)

se testeaza daca aparitiile secventelor "00", "01", "11" si "10" sunt aproximativ egale. Variabila aleatoare X=4/(n-1)(n₀₀²+n₀₁²+n₁₁²+n₁₀²)-2/n(n₀²+n₁²)+1 trebuie sa prezinte o distributie de probabilitate χ² cu doua de libertate daca n>21
testul poker (generalizare test frecventa)

fie m∈N^* ai [n/m] ≥ 5x2^m. Se imparte secventa in k=[n/m] intervale disjuncte, de lungime m. Se noteaza n_i numarul de aparitii ale secventei a i^a, i∈[1, 2^m]. Variabila aleatoare X=2^m/k (∑_i=1^{2^m}n_i²) -k trebuie sa prezinte o distributie de probabilitate χ² cu 2^m-1 grade de libertate
testul de serie

se determina aparitiile seriilor de "0" si "1" de diverse lungimi si se compara cu, aparitiile unei secvente de lungime i pentru o secventa aleatoare de lungime n, e_i=(n-i+3)/2ⁱ⁺². Fie k cea mai mare valoare a lui i pentru care e_i≥ 5. Z_i si U_i reprezinta numerele de secvente de "0" si "1" de lungime i unde i∈[1, k]. Variabila aleatoare X = ∑_i=1^k((Z_i-e_i)²/e_i) + ∑_i=1^k((U_i-e_i)²/e_i)trebuie sa prezinte o distributie de probabilitate χ² cu 2k-2 grade de libertate
testul de autocorelatie
se testeaza corelatia intre secventa si versiuni alunecate ale sale. Fie d ∈[1, [n/2]]. Numarul de biti din secventa, care nu sunt egali cu biti alunecati-d este A(d) = ∑_i=0^n-d-1 s_i ⊕ s_i+d. Variabila aleatoare X = 2 (A(d)-(n-d)/2)/ (n-d)^1/2 trebuie sa prezinte o distributie de probabilitate N(0,1) daca (n-d) ≧ 10
testul Maurer (test universal)

Taxonomie semnaturi digitale

2005-11-15T09:07:00.000+02:00

Alte notatii

spatiul mesajelor, P: multimea mesajelor
spatiul de semnare, P_s: multimea mesajelor ce pot fi semnate
functie redundanta, r: o functie injectiva r:P→P_r
spatiul valorilor de hash, P_h: codomeniul unei functii de dispersie, h:P→P_h
multimea index de semnare, I

Criterii

utilizarea mesajului original de catre algoritmul de verificare
numarul transformarilor

Clasificare

criteriul 1

scheme pentru semnatura digitala cu anexa
necesita mesajul original; fiecare entitate creeaza o cheie privata pentru semnare si o cheie publica pentru verificare
- utilizatorul U selecteaza o multime {sem_U,k; k∈I} care este cheia secreta a lui U; fiecare sem_U,k este o aplicatie injectiva de la P_h la S
- ∀ p∈P_h, s^*∈S, ver_A(p,s^*)=adevarat daca sem_U,k(p)=s^*, altfel ver_A(p,s^*)=fals; ver_A este cheia publica; transformarea se calculeaza fara a cunoaste cheia secreta
scheme pentru semnatura digitala cu recuperare de mesaj
mesajul original este recuperat din semnatura insasi
- utilizatorul U selecteaza o multime {sem_U,k; k∈I} care este cheia secreta a lui U; fiecare sem_U,k este o aplicatie injectiva de la P_s la S
- ∀k∈I, ver_A ○ sem_U,k=1_{P_s}, ver_A este cheia publica; transformarea se calculeaza fara a cunoaste cheia secreta

criteriul 2

schema aleatoare pentru semnatura digitala
Card(I)>1
schema determinista pentru semnatura digitala
Card(I)=1

Semnatura digitala

2005-11-14T13:21:00.000+02:00

Semnatura digitala

Este un mijloc prin care o entitate isi poate lega identitatea de o informatie. Procesul de semnare consta in transformarea unui mesaj si a unei informatii secrete intr-un marcaj care se numeste semnatura

P_s este multimea mesajelor care pot fi semnate
S este multimea elementelor numite semnaturi
sem_k este functia semnatura, sem_k:P_s→S

ver_k

P_s

Algoritm generare semnatura digitala

algoritm pentru producerea unei semnaturi digitale

Algoritm verificare semnatura digitala

algoritm pentru verificarea unei semnaturi digitale

Schema pentru semnatura digitala

Consta intr-un algoritm generare semnatura digitala si intr-un algoritm verificare semnatura digitala; exista o functie bijectiva de la multimea cheilor, K, la produsul SemxVer cu proprietatea ∀ p ∈ P_s, ∀ s ∈ S, ver_k(p,s)=adevarat ⇔ s=sem_k(p)

Procedura pentru semnare digitala

consta intr-un algoritm generare semnatura digitala si o metoda pentru transformarea datelor in mesaje ce pot fi semnate

Procedura pentru verificare semnatura digitala

consta intr-un algoritm pentru verificarea unei semnaturi digitale si o metoda pentru transformarea mesajului in date

Taxonomie functii hash

2005-11-10T17:31:00.000+02:00

Criterii

rezistenta preimagine(sens unic, neinversabila): ∀ y nu este fezabila computational gasirea lui x ai h(x)=y
rezistenta preimagine ord. 2(rezistenta slaba la coliziune): ∀ x nu este fezabila computational gasirea lui x' ai x≠x' ∧ h(x)=h(x')
rezistenta la coliziune(rezistenta puternica la coliziune): nu este fezabila computational gasirea lui x si x' ai x≠x' ∧ h(x)=h(x')
rezistenta la calcul: nu este fezabila computational gasirea lui p_i si p' ai p_i≠p' ∧ h_k(p)=h_k(p') unde k este o cheie, avand la dispozitie mai multe perechi (p_i, h_k(p_i))

Clasificare

MDC(coduri detectoare modificare)
OWHF(functii hash cu sens unic, functie slaba hash cu sens unic): prezinta proprietatile de rezistenta preimagine si rezistenta preimagine ord.2
CRHF(functii hash rezistente la coliziune, functie puternica hash cu sens unic): prezinta proprietatile de rezistenta preimagine ord.2 si rezistenta la coliziune
alte aplicatii
MAC(coduri autentificare mesaj): prezinta proprietatea de rezistenta la calcul
alte aplicatii

Proprietati necesare in aplicatii specifice integritatii datelor

Aplicatia	rezistenta preimagine	rezistenta preimagine ord. 2	rezistenta la coliziune
MDC+semnatura asimetrica	da	da	da
MDC+canal autentic		da	da
MDC+criptare simetrica
fisier parole cu sens unic	da
MAC(cheia necunoscuta atacatorului)	da	da	da
MAC(cheia cunoscuta atacatorului)		da

Functii hash

2005-11-10T11:01:00.000+02:00

Functie hash (functie de dispersie): este o functie eficienta computational care pune in corespondenta siruri binare de lungime arbitrara cu siruri binare de lungime fixa. Sirul de lungime fixa se numeste valoare de hash

Cifru flux

2005-11-10T10:26:00.000+02:00

Cifruri flux (fluide)

Flux de chei (cheie fluida): Fie M= (P, C,K, E,D) un sistem de criptare. O secventa de simboluri k₁k₂k₃… ∈ K⁺ se numeste cheie flux (cheie fluida).
Cifru flux (cifru fluid): Fie A un alfabet cu Card(A)=q si M un cifru de substitutie simpla cu lungimea blocului egala cu 1. Daca k ∈ K⁺ este o cheie flux atunci mesajul criptat c se obtine din mesajul in clar p=p₁p₂p₃… astfel c=c₁c₂c₃ …=e_k₁(p₁)e_k₂(p₂)e_k₃(p₃)…
Cifru flux sincron: Fluxul de chei este generat independent de mesajul in clar si de mesajul criptat
Cifru flux aditiv binar: este un cifru flux sincron in care fluxul de chei, cifrele mesajului in clar si ale mesajululi criptat sunt cifre binare iar functia de criptare realizeaza un XOR intre cifra mesajului in clar si cifra fluxului de chei
Cifru flux asincron (autosincronizabil): Fluxul de chei este generat ca o functie de cheie si un numar fixat de cifre ale mesajului criptat anterior
Entropia: Fie X o variabila aleatoare care ia valorile x₁x₂…x_n cu probabilitatile P(X=x_i)=p_i
Se defineste entropia lui X ca fiind H(X)=∑_i=1ⁿp_ilg(1/p_i) unde prin conventie termenul pentru p_i=0 este 0
"One time pad": Shannon a demonstrat conditia necesara ca o schema de criptare simetrica sa fie sigura
H(k)≥H(p)
adica incertitudinea cheii secrete trebuie sa fie mai mare sau egala cu incertitudinea mesajului clar
Astfel, pentru o cheie de lungime (in biti) k, conditia devine k ≥H(p)

Taxonomie cifruri bloc

2005-11-09T14:05:00.000+02:00

Cifruri bloc: Un cifru bloc este o schema de criptare care sparge mesajul clar in subsiruri (blocuri) cu o lungime fixata peste un alfabet A si cripteaza un bloc o data.
Cifruri de substitutie: Cifrurile de substitutie inlocuiesc simbolurile/bloc de simboluri cu alte simboluri/blocuri de simboluri
monoalfabetice (substitutie simpla): Fie A un alfabet cu Card(A)=q, P multimea sirurilor de lungime t peste A si K multimea tututror permutarilor peste multimea A. Se defineste e_k(p)= (e_k(p₁)e_k(p₂)…e_k(p_t))=(c₁c₂…c_t)=c unde k ∈ K, p ∈ P, c ∈ P
homofonice: ∀ a ∈ P i se asociaza o multime H de subsiruri din C a.i. H(a) ∩ H(b) = ∅ ⇔ a ≠ b
polialfabetice: Fie A un alfabet cu Card(A)=q, P multimea sirurilor de lungime t peste A.
spatiul cheilor K este format din multimile ordonate cu t elemente, elementele fiind permutarile peste A
fie cheia k=(k₁, k₂, …, k_t). Se defineste e_k(p)= (e_k₁(p₁)e_k₂(p₂) …e_{k_t}(p_t))= (c₁c₂…c_t)=c unde k ∈ K, p ∈ P, c ∈ P
Cifru de transpozitie: Fie A un alfabet cu Card(A)=q, P multimea sirurilor de lungime t peste A si K multimea tututror permutarilor peste multimea {1,2,…,t}Se defineste e_k(p)= (e_k(p₁)e_k(p₂)…e_k(p_t))=(c₁c₂…c_t)=c unde k ∈ K, p ∈ P, c ∈ P
Cifru produs: Cifrurile de substitutie simpla si transpozitie nu asigura un nivel satisfacator de securitate. Combinandu-le se pot obtine cifruri puternice si in fapt sistemele de criptare practice sunt cifruri produs

Cifru

2005-11-08T16:25:00.000+02:00

Un sistem de criptare (cifru) este o structura (P, C, K, E, D), unde:

P= {w | w ∈ V*} este multimea ＂textelor clare＂, scrise peste un alfabet nevid V
C= {w | w ∈ W*} este multimea ＂textelor criptate＂, scrise peste un alfabet nevid W (uzual W = V ).
K este o multime de elemente numite chei.
Fiecare cheie K ∈ K determina o metoda de criptare e_K ∈ E si o metoda de decriptare d_K ∈ D . e_K : P → C si d_K : C → P sunt functii cu proprietatea d_K(e_K(w)) = w, ∀ w ∈ P.

Functia e_k este injectiva
Daca e_k este bijectiva, sistemul de criptare se numeste simetric.

Primitive criptografice

2005-11-07T13:57:00.000+02:00

Primitivele criptografice constituie caramizile utilizate la constructia sistemelor destinate a indeplini obiectivele criptografiei

Primitive generale

Permutari cu sens unic
Secvente aleatoare
Functii hash de lungime variabila

Primitive pentru criptografia cu chei simetrice

Cifruri cu chei simetrice

Cifruri bloc
Cifruri flux

Functii hash de lungime variabila
Semnaturi
Secvente pseudoalaeatoare
Primitive de identificare

Primitive pentru criptografia cu chei publice

Cifruri cu chei publice
Semnaturi
Primitive de identificare

Obiectivele criptografiei

2005-11-07T13:28:00.000+02:00

In contextul mai larg al obiectivelor securitatii informatiei, criptografia (cryptos+grafic) se ocupa de aspectele matematice ce privesc urmatoarele:

Confidentialitatea (privat, secret): informatia este disponibila numai entitatilor autorizate
Integritatea datelor (privat, secret): permite detectarea modificarilor aduse datelor de catre o terta parte; modificarile sunt: stergere, inserare, substitutie
Autentificarea: se refera atat la identificarea partilor cat si la informatia transmisa (autentificarea entitatii si autentificarea sursei)
Non-repudierea: prevenirea negarii unei actiuni savarsite de catre o entitate

Plan de lectura

2005-11-07T12:34:00.000+02:00

Introducere in criptografie cu exemple in extensia de criptografie Java

Sumar teoretic al criptografiei
1. Obiectivele criptografiei
2. Primitive criptografice
3. Criptografie cu chei secrete
4. Criptografie cu chei publice
5. Modele de securitate
6. Patente si standarde
Sumar JCE
1. Arhitectura JCE
2. Prezentarea cadrului de lucru in JCE
Exemple de utilizare pentru algoritmii implementati in Java

Surse Curs Timsoft Securitate si Platforma Java Handbook Of Applied Cryptography An Overview of Cryptography Curs criptografie de Adrian Atanasiu Lecture Notes on Cryptography Authors: S. Goldwasser and M. Bellare

1	daca m=1
0	daca m este divizibil cu patratul unui numar prim
(-1)^k	daca m este produsul a k numre prime distincte

operatia	complexitatea (numarul de operatii Z_p)
adunare	O(m)
scadere	O(m)
inmultire	O(m²)
inversare	O(m²)
exponentiere	O(m³lg(p))

functie	nume metoda	obs.
interogare	static Provider[] getProvider()	ordinea in vector este data de ordinea de preferinta a furnizorilor
interogare	static Provider getProvider(Stirng providerName)
adaugare	static int addProvider(Provider provider)	adauga la sfarsitul listei si returneaza ordine de preferinta sau -1 daca furnizorul exista deja
adaugare	insertProviderAt(Provider provider , int position)	insereaza in lista la pozitia "position", aluneca in jos restul listei si returneaza ordinea de preferinta
stergere	static void removeProvider(String name)	dupa stergerea furnizorului componentele listei sunt alunecate in fata cu o pozitie

schema	problema de calcul
RSA	descompunerea in factori, problema RSA
Rabin	descompunerea in factori, radacina patrata modul n compozit
ElGamal	logaritm discret, problema Diffie-Hellman
McEliece	decodarea unui cod liniar
Merkle Hellman	problema rucsacului
Chor-Rivest	problema rucsacului
Goldwasser-Micali	reziduri patratice
Blum-Goldwasser	descompunerea in factori

	lungimea cheii (Nk cuvinte)	lungimea blocului (Nb cuvinte)	numarul de runde (Nr)
AES-128	4	4	10
AES-192	6	4	12
AES-256	8	4	14

y₀		1	0	0	0	1	1	1	1	x₀		1
y₁		1	1	0	0	0	1	1	1	x₁		1
y₂		1	1	1	0	0	0	1	1	x₂		0
y₃	=	1	1	1	1	0	0	0	1	x₃	+	0
y₄		1	1	1	1	1	0	0	0	x₄		0
y₅		0	1	1	1	1	1	0	0	x₅		1
y₆		0	0	1	1	1	1	1	0	x₆		1
y₇		0	0	0	1	1	1	1	1	x₇		0

	0	1	2	3	4	5	6	7	8	9	a	b	c	d	e	f
0	63	7c
1	ca	82
2	b7	fd
3	04	c7
4	09	83
5	53	d1
6	d0	ef
7	51	a3
8	cd	0c
9	60	81
a	e0	32
b	e7	c8
c	ba	78
d	70	3e
e	e1	f8
f	8c	a1

s_{0, c}		'02'	'03'	'01'	'01'	s_{0, c}
s_{1, c}	=	'01'	'02'	'03'	'01'	s_{1, c}
s_{2, c}		'01'	'01'	'02'	'03'	s_{2, c}
s_{3, c}		'03'	'01'	'01'	'02'	s_{3, c}

s_{0, c}		'0e'	'0b'	'0d'	'09'	s_{0, c}
s_{1, c}	=	'09'	'0e'	'0b'	'0d'	s_{1, c}
s_{2, c}		'0d'	'09'	'0e'	'0b'	s_{2, c}
s_{3, c}		'0b'	'0d'	'09'	'0e'	s_{3, c}

for i = 0 step 1 to (Nr+1)*Nb-1
	dw[i] = w[i]
end for
for round = 1 step 1 to Nr-1
	InvMixColumns(dw[roundNb, (round+1)Nb-1])
end for

57	49	41	33	25	17	9
1	58	50	42	34	26	18
10	2	59	51	43	35	27
19	11	3	60	52	44	36
63	55	47	39	31	23	15
7	62	54	46	38	30	22
14	6	61	53	45	37	29
21	13	5	28	20	12	4

14	17	11	24	1	5
3	28	15	6	21	10
23	19	12	4	26	8
16	7	27	20	13	2
41	52	31	37	47	55
30	40	51	45	33	48
44	49	39	56	34	53
46	42	50	36	29	32

	adevarat	daca S_A,k(p) = s^*
V_A(p, s^*) =
	fals	altfel

Nb/r	1	2	3
4	1	2	3
6	1	2	3
8	1	3	4

L_i =	R_i-1
R_i =	L_i-1 ⊕ f(R_i-1 , K_i)

L_i =	R_i-1
R_i =	L_i-1 ⊕ f(R_i-1 , K_i)

	0	1	2	3	4	5	6	7	8	9	a	b	c	d	e	f
0	63	7c
1	ca	82
2	b7	fd
3	04	c7
4	09	83
5	53	d1
6	d0	ef
7	51	a3
8	cd	0c
9	60	81
a	e0	32
b	e7	c8
c	ba	78
d	70	3e
e	e1	f8
f	8c	a1

57	49	41	33	25	17	9
1	58	50	42	34	26	18
10	2	59	51	43	35	27
19	11	3	60	52	44	36
63	55	47	39	31	23	15
7	62	54	46	38	30	22
14	6	61	53	45	37	29
21	13	5	28	20	12	4

14	17	11	24	1	5
3	28	15	6	21	10
23	19	12	4	26	8
16	7	27	20	13	2
41	52	31	37	47	55
30	40	51	45	33	48
44	49	39	56	34	53
46	42	50	36	29	32

58	50	42	34	26	18	10	2
60	52	44	36	28	20	12	4
62	54	46	38	30	22	14	6
64	56	48	40	32	24	16	8
57	49	41	33	25	17	9	1
59	51	43	35	27	19	11	3
61	53	45	37	29	21	13	5
63	55	47	39	31	23	15	7

32	1	2	3	4	5
4	5	6	7	8	9
8	9	10	11	12	13
12	13	14	15	16	17
16	17	18	19	20	21
20	21	22	23	24	25
24	25	26	27	28	29
28	29	30	31	32	1

r/c	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	14	4	13	1	2	15	11	8	3	10	6	12	5	9	0	7
1	0	15	7	4	14	2	13	1	10	6	12	11	9	5	3	8
2	4	1	14	8	13	6	2	11	15	12	9	7	3	10	5	0
3	15	12	8	2	4	9	1	7	5	11	3	14	10	0	6	13

r/c	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	15	1	8	14	6	11	3	4	9	7	2	13	12	0	5	10
1	3	13	4	7	15	2	8	14	12	0	1	10	6	9	11	5
2	0	14	7	11	10	4	13	1	5	8	12	6	9	3	2	15
3	13	8	10	1	3	15	4	2	11	6	7	12	0	5	14	9

r/c	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	10	0	9	14	6	3	15	5	1	13	12	7	11	4	2	8
1	13	7	0	9	3	4	6	10	2	8	5	14	12	11	15	1
2	13	6	4	9	8	15	3	0	11	1	2	12	5	10	14	7
3	1	10	13	0	6	9	8	7	4	15	14	3	11	5	2	12

r/c	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	7	13	14	3	0	6	9	10	1	2	8	5	11	12	4	15
1	13	8	11	5	6	15	0	3	4	7	2	12	1	10	14	9
2	10	6	9	0	12	11	7	13	15	1	3	14	5	2	8	4
3	3	15	0	6	10	1	13	8	9	4	5	11	12	7	2	14

r/c	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	2	12	4	1	7	10	11	6	8	5	3	15	13	0	14	9
1	14	11	2	12	4	7	13	1	5	0	15	10	3	9	8	6
2	4	2	1	11	10	13	7	8	15	9	12	5	6	3	0	14
3	11	8	12	7	1	14	2	13	6	15	0	9	10	4	5	3

	0	1	2	3	4	5	6	7	8	9	a	b	c	d	e	f
0	63	7c
1	ca	82
2	b7	fd
3	04	c7
4	09	83
5	53	d1
6	d0	ef
7	51	a3
8	cd	0c
9	60	81
a	e0	32
b	e7	c8
c	ba	78
d	70	3e
e	e1	f8
f	8c	a1

57	49	41	33	25	17	9
1	58	50	42	34	26	18
10	2	59	51	43	35	27
19	11	3	60	52	44	36
63	55	47	39	31	23	15
7	62	54	46	38	30	22
14	6	61	53	45	37	29
21	13	5	28	20	12	4

14	17	11	24	1	5
3	28	15	6	21	10
23	19	12	4	26	8
16	7	27	20	13	2
41	52	31	37	47	55
30	40	51	45	33	48
44	49	39	56	34	53
46	42	50	36	29	32

58	50	42	34	26	18	10	2
60	52	44	36	28	20	12	4
62	54	46	38	30	22	14	6
64	56	48	40	32	24	16	8
57	49	41	33	25	17	9	1
59	51	43	35	27	19	11	3
61	53	45	37	29	21	13	5
63	55	47	39	31	23	15	7

32	1	2	3	4	5
4	5	6	7	8	9
8	9	10	11	12	13
12	13	14	15	16	17
16	17	18	19	20	21
20	21	22	23	24	25
24	25	26	27	28	29
28	29	30	31	32	1

r/c	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	14	4	13	1	2	15	11	8	3	10	6	12	5	9	0	7
1	0	15	7	4	14	2	13	1	10	6	12	11	9	5	3	8
2	4	1	14	8	13	6	2	11	15	12	9	7	3	10	5	0
3	15	12	8	2	4	9	1	7	5	11	3	14	10	0	6	13

r/c	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	15	1	8	14	6	11	3	4	9	7	2	13	12	0	5	10
1	3	13	4	7	15	2	8	14	12	0	1	10	6	9	11	5
2	0	14	7	11	10	4	13	1	5	8	12	6	9	3	2	15
3	13	8	10	1	3	15	4	2	11	6	7	12	0	5	14	9

r/c	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	10	0	9	14	6	3	15	5	1	13	12	7	11	4	2	8
1	13	7	0	9	3	4	6	10	2	8	5	14	12	11	15	1
2	13	6	4	9	8	15	3	0	11	1	2	12	5	10	14	7
3	1	10	13	0	6	9	8	7	4	15	14	3	11	5	2	12

r/c	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	7	13	14	3	0	6	9	10	1	2	8	5	11	12	4	15
1	13	8	11	5	6	15	0	3	4	7	2	12	1	10	14	9
2	10	6	9	0	12	11	7	13	15	1	3	14	5	2	8	4
3	3	15	0	6	10	1	13	8	9	4	5	11	12	7	2	14

r/c	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
0	2	12	4	1	7	10	11	6	8	5	3	15	13	0	14	9
1	14	11	2	12	4	7	13	1	5	0	15	10	3	9	8	6
2	4	2	1	11	10	13	7	8	15	9	12	5	6	3	0	14
3	11	8	12	7	1	14	2	13	6	15	0	9	10	4	5	3