repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/alwaysDefineCSP/src/main/java/example/DefinedProvider5.java | package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class DefinedProvider5 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
KeyGenerator kg = KeyGenerator.getInstance("AES","BC");
kg.getProvider().getName();
Cipher enc = Cipher.getInstance("AES/CTR/NoPadding","BC");
enc.getProvider().getName();
Cipher dec = Cipher.getInstance("AES/CTR/NoPadding","BC");
dec.getProvider().getName();
}
}
| 1,142 | 31.657143 | 75 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/alwaysDefineCSP/src/main/java/example/DefinedProvider6.java | package example;
import javax.crypto.*;
import java.security.*;
public final class DefinedProvider6 {
public static void main (String args[])
throws
NoSuchAlgorithmException,
NoSuchPaddingException,
InvalidKeyException,
BadPaddingException,
IllegalBlockSizeException,
NoSuchProviderException
{
byte[] msg = "This is a test msg".getBytes();
KeyGenerator kg = KeyGenerator.getInstance("AES","SunJCE");
kg.init(256);
Key key = kg.generateKey();
Cipher ciph = Cipher.getInstance("AES","SunJCE");
ciph.init(Cipher.ENCRYPT_MODE, key);
byte[] ciphMsg = ciph.doFinal(msg);
ciph.init(Cipher.DECRYPT_MODE, key);
byte[] originalMsg = ciph.doFinal(ciphMsg);
}
}
| 822 | 28.392857 | 67 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/alwaysDefineCSP/src/main/java/example/DefinedProvider7.java | package example;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class DefinedProvider7 {
public static void main(String args[]) {
try {
Security.addProvider(new BouncyCastleProvider());
byte[] msgA = ("Insecure default RSA.").getBytes();
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(2048);
KeyPair kp = kpg.generateKeyPair();
Cipher enc = Cipher.getInstance("RSA", "BC");
enc.init(Cipher.ENCRYPT_MODE, kp.getPublic());
Cipher dec = Cipher.getInstance("RSA", "BC");
dec.init(Cipher.DECRYPT_MODE, kp.getPrivate());
byte[][] ct = new byte[2][];
for (int i = 0; i < 2; i++) {
ct[i] = enc.doFinal(msgA);
byte[] ptB = dec.doFinal(ct[i]);
}
} catch (NoSuchAlgorithmException | NoSuchPaddingException |
InvalidKeyException | IllegalBlockSizeException |
BadPaddingException | NoSuchProviderException e) {}
}
}
| 1,387 | 32.853659 | 71 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidCodingErrors/src/main/java/example/DoNotConcatenateHash.java | package example;
import java.io.UnsupportedEncodingException;
import java.security.*;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class DoNotConcatenateHash {
static MessageDigest md;
static String i32 = "abcdefghijklmnopqrstuvxwyz012345";
static String secret = i32;
static String resource = i32;
static String extension = i32 + i32;
static boolean verify(byte[] half1, byte[] half2, byte[] hash)
throws NoSuchAlgorithmException, NoSuchProviderException {
Security.addProvider(new BouncyCastleProvider());
md = MessageDigest.getInstance("SHA-256", "BC");
md.update(half1);
md.update(half2);
byte[] h = md.digest();
return MessageDigest.isEqual(h, hash);
}
static boolean server(byte[] half2, byte[] hash) {
boolean ok = false;
try {
ok = verify(secret.getBytes("UTF-8"), half2, hash);
} catch (UnsupportedEncodingException | NoSuchAlgorithmException |
NoSuchProviderException e) {}
return ok;
}
public static void main(String[] a) {
try {
Security.addProvider(new BouncyCastleProvider());
md = MessageDigest.getInstance("SHA-256", "BC");
byte[] h = md.digest((secret+resource).getBytes("UTF-8"));
boolean ok = server(resource.getBytes("UTF-8"), h);
} catch (NoSuchAlgorithmException | NoSuchProviderException |
UnsupportedEncodingException e) {}
}
} | 1,432 | 30.152174 | 71 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidCodingErrors/src/main/java/example/DoNotSaveToString.java | package example;
import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class DoNotSaveToString {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException, UnsupportedEncodingException {
Security.addProvider(new BouncyCastleProvider());
byte[] ptA = ("Testing String").getBytes("UTF-8");
byte[] iv = new byte[16];
SecureRandom.getInstanceStrong().nextBytes(iv);
KeyGenerator kg = KeyGenerator.getInstance("AES", "BC");
kg.init(128);
Key key = kg.generateKey();
String alg = "AES/CTR/NoPadding";
Cipher enc = Cipher.getInstance(alg,"BC");
Cipher dec = Cipher.getInstance(alg,"BC");
byte[] ct;
enc.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(iv));
ct = enc.doFinal(ptA);
dec.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(iv));
byte[] ptB = dec.doFinal(ct);
dec.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(iv));
ptB = dec.doFinal(ct);
}
}
| 1,730 | 32.288462 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidCodingErrors/src/main/java/example/GenerateRandomIV.java |
package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class GenerateRandomIV {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
byte[] ptA = ("Test String").getBytes();
byte[] iv = new byte[16];
SecureRandom.getInstanceStrong().nextBytes(iv);
KeyGenerator kg = KeyGenerator.getInstance("AES", "BC");
kg.init(128);
Key key = kg.generateKey();
String[] algs = {"AES/OFB/NoPadding", "AES/CFB/NoPadding", "AES/CTR/NoPadding"};
boolean fixIV = true;
for (int a = 0; a < algs.length; a++) {
Cipher enc = Cipher.getInstance(algs[a], "BC");
Cipher dec = Cipher.getInstance(algs[a], "BC");
byte[][] ct = new byte[2][];
for (int i = 0; i < 2; i++) {
enc.init(Cipher.ENCRYPT_MODE, key, new IvParameterSpec(iv));
ct[i] = enc.doFinal(ptA);
dec.init(Cipher.DECRYPT_MODE, key, new IvParameterSpec(iv));
byte[] ptB = dec.doFinal(ct[i]);
if (!fixIV) iv[iv.length-1] = (byte) (iv[iv.length-1]^0x01);
}
}
}
}
| 1,848 | 34.557692 | 84 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidCodingErrors/src/main/java/example/PBEwLargeCountAndRandomSalt.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.spec.PBEKeySpec;
import org.bouncycastle.jce.provider.*;
//
public final class PBEwLargeCountAndRandomSalt {
@SuppressWarnings("empty-statement")
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidKeySpecException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
if (args != null) {
char[] pass = args[0].toCharArray();
byte[] salt = new byte[16];
(SecureRandom.getInstanceStrong()).nextBytes(salt);
int iterationCount = 2048;
PBEKeySpec pbeks = new PBEKeySpec(pass, salt, iterationCount);
SecretKeyFactory skf = SecretKeyFactory.getInstance("PBEWithSHA256And128BitAES-CBC-BC", "BC");
Key key = skf.generateSecret(pbeks);
Cipher c = Cipher.getInstance("AES/CTR/NoPadding", "BC");
c.init(Cipher.ENCRYPT_MODE, key);
byte[] textA = "Testing AES".getBytes();
byte[] bytearray = c.doFinal(textA);
c.init(Cipher.DECRYPT_MODE, key);
byte[] textB = c.doFinal(bytearray);
}
}
}
| 1,326 | 30.595238 | 100 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidConstantPwdPBE/src/main/java/example/PBEwParameterPassword.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.spec.PBEKeySpec;
import org.bouncycastle.jce.provider.*;
//
public final class PBEwParameterPassword {
@SuppressWarnings("empty-statement")
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidKeySpecException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
if (args != null) {
char[] pass = args[0].toCharArray();
byte[] salt = new byte[16];
(SecureRandom.getInstanceStrong()).nextBytes(salt);
int iterationCount = 2048;
PBEKeySpec pbeks = new PBEKeySpec(pass, salt, iterationCount);
SecretKeyFactory skf = SecretKeyFactory.getInstance("PBEWithSHA256And128BitAES-CBC-BC", "BC");
Key key = skf.generateSecret(pbeks);
Cipher c = Cipher.getInstance("AES/CTR/NoPadding", "BC");
c.init(Cipher.ENCRYPT_MODE, key);
byte[] textA = "Testing AES".getBytes();
byte[] bytearray = c.doFinal(textA);
c.init(Cipher.DECRYPT_MODE, key);
byte[] textB = c.doFinal(bytearray);
}
}
}
| 1,319 | 31.195122 | 100 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidDeterministicRSA/src/main/java/example/UseOAEPForRSA.java | package example;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class UseOAEPForRSA {
public static void main(String args[]) {
try {
Security.addProvider(new BouncyCastleProvider());
byte[] ptA = ("Randomized RSA").getBytes();
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(2048);
KeyPair kp = kpg.generateKeyPair();
Cipher enc = Cipher.getInstance("RSA/None/OAEPWithSHA256AndMGF1Padding", "BC");
enc.init(Cipher.ENCRYPT_MODE, kp.getPublic());
Cipher dec = Cipher.getInstance("RSA/None/OAEPWithSHA256AndMGF1Padding", "BC");
dec.init(Cipher.DECRYPT_MODE, kp.getPrivate());
byte[][] ct = new byte[2][];
for (int i = 0; i < 2; i++) {
ct[i] = enc.doFinal(ptA);
byte[] ptB = dec.doFinal(ct[i]);
}
} catch (NoSuchAlgorithmException | NoSuchPaddingException |
InvalidKeyException | IllegalBlockSizeException |
BadPaddingException | NoSuchProviderException e) {}
}
}
| 1,442 | 35.075 | 85 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidDeterministicRSA/src/main/java/example/UsePKCS1ForRSA.java | package example;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class UsePKCS1ForRSA {
public static void main(String args[]) {
try {
Security.addProvider(new BouncyCastleProvider());
byte[] ptA = ("Randomized RSA").getBytes();
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(2048);
KeyPair kp = kpg.generateKeyPair();
Cipher enc = Cipher.getInstance("RSA/None/PKCS1Padding", "BC");
enc.init(Cipher.ENCRYPT_MODE, kp.getPublic());
Cipher dec = Cipher.getInstance("RSA/None/PKCS1Padding", "BC");
dec.init(Cipher.DECRYPT_MODE, kp.getPrivate());
byte[][] cryptotext = new byte[2][];
for (int i = 0; i < 2; i++) {
cryptotext[i] = enc.doFinal(ptA);
byte[] ptB = dec.doFinal(cryptotext[i]);
}
} catch (NoSuchAlgorithmException | NoSuchPaddingException |
InvalidKeyException | IllegalBlockSizeException |
BadPaddingException | NoSuchProviderException e) {}
}
}
| 1,436 | 34.04878 | 71 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidFixedPredictableSeed/src/main/java/example/DoNotUseWeakSeed1.java | package example;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
public final class DoNotUseWeakSeed1 {
public static void main(String[] args) {
try {
SecureRandom r1 = SecureRandom.getInstance("SHA1PRNG", "SUN");
SecureRandom r2 = SecureRandom.getInstanceStrong();
r1.setSeed(r2.nextLong());
} catch (NoSuchAlgorithmException | NoSuchProviderException e) {}
}
}
| 486 | 24.631579 | 69 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidFixedPredictableSeed/src/main/java/example/DoNotUseWeakSeed2.java | package example;
import java.security.SecureRandom;
public final class DoNotUseWeakSeed2 {
public static void main(String[] args) {
try {
SecureRandom r1 = SecureRandom.getInstanceStrong();
SecureRandom r2 = SecureRandom.getInstanceStrong();
} catch (Exception e) {}
}
}
| 309 | 18.375 | 58 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidFixedPredictableSeed/src/main/java/example/DoNotUseWeakSeed3.java | package example;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
public final class DoNotUseWeakSeed3 {
public static void main(String[] args) {
try {
SecureRandom r1 = SecureRandom.getInstance("SHA1PRNG", "SUN");
SecureRandom r2 = SecureRandom.getInstanceStrong();
byte[] seed = new byte[16];
r2.nextBytes(seed);
r1.setSeed(seed);
} catch (NoSuchAlgorithmException | NoSuchProviderException e) {}
}
}
| 536 | 25.85 | 69 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidFixedPredictableSeed/src/main/java/example/DoNotUseWeakSeed4.java | package example;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
public final class DoNotUseWeakSeed4 {
public static void main(String[] args) {
try {
SecureRandom r1 = SecureRandom.getInstance("SHA1PRNG", "SUN");
SecureRandom r2 = SecureRandom.getInstanceStrong();
byte[] seed = new byte[16];
r1.setSeed(r2.generateSeed(16));
} catch (NoSuchAlgorithmException | NoSuchProviderException e) {}
}
}
| 526 | 26.736842 | 69 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidHardcodedKeys/src/main/java/example/UseDynamicKeyFor3DES.java | package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
public final class UseDynamicKeyFor3DES {
public static void main(String[] a) {
try {
KeyGenerator g = KeyGenerator.getInstance("DESede", "SunJCE");
g.init(168);
Key k = g.generateKey();
byte[] iv = new byte[8];
SecureRandom.getInstanceStrong().nextBytes(iv);
byte[] msg = "This is a test for 3DES.".getBytes();
Cipher c = Cipher.getInstance("DESede/CTR/NoPadding", "SunJCE");
AlgorithmParameterSpec aps = new IvParameterSpec(iv);
c.init(Cipher.ENCRYPT_MODE, k, aps);
byte[] ct = c.doFinal(msg);
SecretKeySpec ks1 = new SecretKeySpec(k.getEncoded(), "DESede");
c.init(Cipher.DECRYPT_MODE, ks1, aps);
byte[] pt = c.doFinal(ct);
} catch (InvalidKeyException | NoSuchAlgorithmException |
NoSuchPaddingException | InvalidAlgorithmParameterException |
IllegalBlockSizeException | BadPaddingException |
NoSuchProviderException e) {}
}
}
| 1,426 | 37.567568 | 77 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidHardcodedKeys/src/main/java/example/UseDynamicKeyForAES.java | package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.spec.*;
import javax.crypto.*;
import javax.crypto.spec.*;
public final class UseDynamicKeyForAES {
public static void main(String[] a) {
try {
KeyGenerator g = KeyGenerator.getInstance("AES","SunJCE");
g.init(128);
Key k = g.generateKey();
byte[] iv = new byte[16];
SecureRandom.getInstanceStrong().nextBytes(iv);
byte[] msg = "This is a test for AES..".getBytes();
Cipher c = Cipher.getInstance("AES/CTR/NoPadding", "SunJCE");
AlgorithmParameterSpec aps = new IvParameterSpec(iv);
c.init(Cipher.ENCRYPT_MODE, k, aps);
byte[] ct = c.doFinal(msg);
SecretKeySpec ks1 = new SecretKeySpec(k.getEncoded(), "AES");
c.init(Cipher.DECRYPT_MODE, ks1, aps);
byte[] pt = c.doFinal(ct);
} catch (InvalidKeyException | NoSuchAlgorithmException |
NoSuchPaddingException | InvalidAlgorithmParameterException |
IllegalBlockSizeException | BadPaddingException |
NoSuchProviderException e) {}
}
}
| 1,415 | 37.27027 | 77 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidHardcodedKeys/src/main/java/example/UseDynamicKeyforMAC1.java |
package example;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
public final class UseDynamicKeyforMAC1 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
byte[] key = new byte[16];
SecureRandom.getInstanceStrong().nextBytes(key);
SecretKeySpec sks = new SecretKeySpec(key, "HMACSHA256");
Mac m = Mac.getInstance("HMACSHA256","SunJCE");
byte[] msg = "This is a test for MAC".getBytes(), X;
m.init(sks);
byte[] tag = m.doFinal(msg);
boolean ok = MessageDigest.isEqual(m.doFinal(msg), tag);
}
}
| 791 | 28.333333 | 75 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidHardcodedKeys/src/main/java/example/UseDynamicKeyforMAC2.java |
package example;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.SecretKeySpec;
public final class UseDynamicKeyforMAC2 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
KeyGenerator g = KeyGenerator.getInstance("HMACSHA256", "SunJCE");
g.init(256);
Key k1 = g.generateKey();
Mac m = Mac.getInstance("HMACSHA256", "SunJCE");
byte[] msg = "This is a test for MAC".getBytes();
m.init(k1);
byte[] tag = m.doFinal(msg);
SecretKeySpec sks = new SecretKeySpec(k1.getEncoded(), "HMACSHA256");
m.init(sks);
byte[] tag2 = m.doFinal(msg);
boolean ok = MessageDigest.isEqual(tag2,tag);
}
}
| 878 | 28.3 | 75 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidImproperKeyLen/src/main/java/example/SecureConfig112bitsRSA_2048x256_1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig112bitsRSA_2048x256_1 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int keysize = 2048;
int hashsize = 256;
int maxLenBytes = (keysize - 2 * hashsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(keysize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA256;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA-256", "MGF1", mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] ptA = "This is a test string".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] ptB = c.doFinal(ct);
}
}
| 1,296 | 29.880952 | 106 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidImproperKeyLen/src/main/java/example/SecureConfig112bitsRSA_2048x256_2.java | package example;
import javax.crypto.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig112bitsRSA_2048x256_2 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 256;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
Cipher c = Cipher.getInstance("RSA/None/OAEPwithSHA256andMGF1Padding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk);
byte[] ptA = "This is a test string".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk);
byte[] ptB = c.doFinal(ct);
}
}
| 1,031 | 27.666667 | 101 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidImproperKeyLen/src/main/java/example/SecureConfig128bitsRSA_3072x384_1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig128bitsRSA_3072x384_1 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 3072;
int hsize = 384;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA384;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA-384", "MGF1", mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] ptA = "This is a test string".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] ptB = c.doFinal(ct);
}
}
| 1,284 | 29.595238 | 106 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidImproperKeyLen/src/main/java/example/SecureConfig128bitsRSA_3072x384_2.java | package example;
import javax.crypto.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig128bitsRSA_3072x384_2 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 3072;
int hsize = 384;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
Cipher c = Cipher.getInstance("RSA/None/OAEPwithSHA384andMGF1Padding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk);
byte[] ptA = "This is a test string".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk);
byte[] ptB = c.doFinal(ct);
}
}
| 1,031 | 27.666667 | 101 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidImproperKeyLen/src/main/java/example/SecureConfig128bitsRSA_4096x512_1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig128bitsRSA_4096x512_1 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 4096;
int hsize = 512;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA512;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA-512", "MGF1", mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] ptA = "This is a test string".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] ptB = c.doFinal(ct);
}
}
| 1,284 | 29.595238 | 106 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidImproperKeyLen/src/main/java/example/SecureConfig128bitsRSA_4096x512_2.java | package example;
import javax.crypto.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig128bitsRSA_4096x512_2 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 4096;
int hsize = 512;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
Cipher c = Cipher.getInstance("RSA/None/OAEPwithSHA512andMGF1Padding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk);
byte[] ptA = "This is a test string".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk);
byte[] ptB = c.doFinal(ct);
}
}
| 1,031 | 27.666667 | 101 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidImproperKeyLen/src/main/java/example/SecureConfig192bitsRSA_7680x384_1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig192bitsRSA_7680x384_1 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 7680;
int hsize = 384;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA384;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA-384", "MGF1", mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] ptA = "This is a test string".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] ptB = c.doFinal(ct);
}
}
| 1,284 | 29.595238 | 106 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidImproperKeyLen/src/main/java/example/SecureConfig192bitsRSA_7680x512_1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig192bitsRSA_7680x512_1 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 7680;
int hsize = 512;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA512;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA-512", "MGF1", mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] ptA = "This is a test string".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] ptB = c.doFinal(ct);
}
}
| 1,284 | 29.595238 | 106 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureDefaults/src/main/java/example/UseExplicitMode1.java |
package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
//
public final class UseExplicitMode1 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
byte[] ptA = ("Testing explicit operation modes").getBytes();
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
byte[] iv = new byte[16];
SecureRandom sr = SecureRandom.getInstanceStrong();
String[]aesOpModes = {"AES/OFB/NoPadding","AES/OFB128/NoPadding",
"AES/CFB/NoPadding","AES/CFB128/NoPadding",
"AES/CTR/NoPadding","AES/CTS/NoPadding",
"AES/CBC/NoPadding",};
for (int a = 0; a < aesOpModes.length; a++) {
Cipher enc = Cipher.getInstance(aesOpModes[a], "BC");
Cipher dec = Cipher.getInstance(aesOpModes[a], "BC");
for (int i = 0; i < 10; i++) {
sr.nextBytes(iv);
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv));
byte[] ct = enc.doFinal(ptA);
dec.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(enc.getIV()));
byte[] ptB = dec.doFinal(ct);
}
}
}
}
| 1,974 | 34.909091 | 75 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureDefaults/src/main/java/example/UseExplicitPadding1.java |
package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
//
public final class UseExplicitPadding1 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
byte[] ptA = ("Testing explicit operation modes").getBytes();
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
byte[] iv = new byte[16];
SecureRandom sr = SecureRandom.getInstanceStrong();
String[] opModes = {"AES/OFB","AES/OFB128","AES/CFB","AES/CFB128",
"AES/CTR","AES/CTS","AES/CBC"};
String[] paddings ={"NoPadding","PKCS5Padding","ISO10126Padding"};
for (int a = 0; a < opModes.length; a++) {
for (int p = 0; p < 3; p++) {
String explicitModeAndPadding = opModes[a] +"/"+ paddings[p];
Cipher enc = Cipher.getInstance(explicitModeAndPadding, "BC");
Cipher dec = Cipher.getInstance(explicitModeAndPadding, "BC");
for (int i = 0; i < 10; i++) {
sr.nextBytes(iv);
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv));
byte[] ct = enc.doFinal(ptA);
dec.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(enc.getIV()));
byte[] ptB = dec.doFinal(ct);
}
}
}
}
}
| 2,061 | 35.175439 | 77 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureDefaults/src/main/java/example/UseQualifiedNameForPBE1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import javax.crypto.spec.PBEKeySpec;
import org.bouncycastle.jce.provider.*;
//
public final class UseQualifiedNameForPBE1 {
@SuppressWarnings("empty-statement")
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidKeySpecException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
if (args != null) {
char[] password = args[0].toCharArray();
byte[] salt = new byte[16];
(SecureRandom.getInstanceStrong()).nextBytes(salt);
int iterationCount = 2048;
PBEKeySpec pbeks = new PBEKeySpec(password, salt, iterationCount);
SecretKeyFactory skf
= SecretKeyFactory.getInstance("PBEWithSHA256And128BitAES-CBC-BC", "BC");
Key sk = skf.generateSecret(pbeks);
Cipher c = Cipher.getInstance("AES/CTR/NoPadding", "BC");
c.init(Cipher.ENCRYPT_MODE, sk);
byte[] ptA = "Testing AES".getBytes();
byte[] ct = c.doFinal(ptA);
c.init(Cipher.DECRYPT_MODE, sk);
byte[] ptB = c.doFinal(ct);
}
}
}
| 1,321 | 29.744186 | 87 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureDefaults/src/main/java/example/UseQualifiedNameForRSAOAEP.java | package example;
import javax.crypto.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
public final class UseQualifiedNameForRSAOAEP {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 256;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
Cipher c = Cipher.getInstance("RSA/None/OAEPwithSHA256andMGF1Padding","BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk);
byte[] ptA = "This is a demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk);
byte[] ptB = c.doFinal(ct);
}
}
| 1,091 | 28.513514 | 80 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureDefaults/src/main/java/example/UseQualifiedParamsForRSAOAEP.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class UseQualifiedParamsForRSAOAEP {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 256;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA1;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA256", "MGF1",
mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] ptA = "This is a demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] ptB = c.doFinal(ct);
}
} | 1,358 | 31.357143 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureDefaults/src/main/java/example/UseSecureDefaultForPRNG.java | package example;
import java.security.SecureRandom;
public final class UseSecureDefaultForPRNG {
public static void main(String[] args) {
try {
SecureRandom r1 = SecureRandom.getInstanceStrong();
SecureRandom r2 = SecureRandom.getInstanceStrong();
} catch (Exception e) {}
}
}
| 306 | 20.928571 | 57 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureHash/src/main/java/example/UseSHA2_1.java | package example;
import java.security.*;
public final class UseSHA2_1 {
static String[] hashes = {"SHA-224", "SHA-256", "SHA-384", "SHA-512"};
static MessageDigest md;
public static void main(String[] a) {
try {
for (int i = 0; i < 4; i++) {
md = MessageDigest.getInstance(hashes[i],"SUN");
String input = "";
md.update(input.getBytes());
byte[] output = md.digest();
input = "abc";
md.update(input.getBytes());
output = md.digest();
input = "abcdefghijklmnopqrstuvwxyz";
md.update(input.getBytes());
output = md.digest();
}
} catch (NoSuchAlgorithmException | NoSuchProviderException e) {}
}
}
| 724 | 24.892857 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureHash/src/main/java/example/UseSHA2_2.java | package example;
import java.security.*;
public final class UseSHA2_2 {
static MessageDigest md;
public static void main(String[] a) {
try {
md = MessageDigest.getInstance("SHA-224","SUN");
String input = "";
md.update(input.getBytes());
byte[] output = md.digest();
input = "abc";
md.update(input.getBytes());
output = md.digest();
input = "abcdefghijklmnopqrstuvwxyz";
md.update(input.getBytes());
output = md.digest();
md = MessageDigest.getInstance("SHA-256","SUN");
input = "";
md.update(input.getBytes());
output = md.digest();
input = "abc";
md.update(input.getBytes());
output = md.digest();
input = "abcdefghijklmnopqrstuvwxyz";
md.update(input.getBytes());
output = md.digest();
md = MessageDigest.getInstance("SHA-384","SUN");
input = "";
md.update(input.getBytes());
output = md.digest();
input = "abc";
md.update(input.getBytes());
output = md.digest();
input = "abcdefghijklmnopqrstuvwxyz";
md.update(input.getBytes());
output = md.digest();
md = MessageDigest.getInstance("SHA-512","SUN");
input = "";
md.update(input.getBytes());
output = md.digest();
input = "abc";
md.update(input.getBytes());
output = md.digest();
input = "abcdefghijklmnopqrstuvwxyz";
md.update(input.getBytes());
output = md.digest();
} catch (NoSuchAlgorithmException | NoSuchProviderException e) {}
}
}
| 1,579 | 26.241379 | 69 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureHash/src/main/java/example/UseSHA3_1.java | package example;
import java.security.*;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class UseSHA3_1 {
static MessageDigest md;
public static void main(String[] a) {
try {
Security.addProvider(new BouncyCastleProvider());
md = MessageDigest.getInstance("SHA3-224", "BC");
String input = "";
md.update(input.getBytes());
byte[] output = md.digest();
input = "abc";
md.update(input.getBytes());
output = md.digest();
input = "abcdefghijklmnopqrstuvwxyz";
md.update(input.getBytes());
output = md.digest();
md = MessageDigest.getInstance("SHA3-256", "BC");
input = "";
md.update(input.getBytes());
output = md.digest();
input = "abc";
md.update(input.getBytes());
output = md.digest();
input = "abcdefghijklmnopqrstuvwxyz";
md.update(input.getBytes());
output = md.digest();
md = MessageDigest.getInstance("SHA3-384", "BC");
input = "";
md.update(input.getBytes());
output = md.digest();
input = "abc";
md.update(input.getBytes());
output = md.digest();
input = "abcdefghijklmnopqrstuvwxyz";
md.update(input.getBytes());
output = md.digest();
md = MessageDigest.getInstance("SHA3-512", "BC");
input = "";
md.update(input.getBytes());
output = md.digest();
input = "abc";
md.update(input.getBytes());
output = md.digest();
input = "abcdefghijklmnopqrstuvwxyz";
md.update(input.getBytes());
output = md.digest();
} catch (Exception e) {}
}
}
| 1,664 | 26.295082 | 58 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureHash/src/main/java/example/UseSHA3_2.java | package example;
import java.security.*;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class UseSHA3_2 {
static String[] hashes = {"SHA3-224", "SHA3-256", "SHA3-384", "SHA3-512"};
static MessageDigest md;
public static void main(String[] a) {
try {
Security.addProvider(new BouncyCastleProvider());
for (int i = 0; i < 4; i++) {
md = MessageDigest.getInstance(hashes[i], "BC");
String input = "";
md.update(input.getBytes());
byte[] output = md.digest();
input = "abc";
md.update(input.getBytes());
output = md.digest();
input = "abcdefghijklmnopqrstuvwxyz";
md.update(input.getBytes());
output = md.digest();
}
} catch (NoSuchAlgorithmException | NoSuchProviderException e) {}
}
}
| 835 | 26.866667 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureMAC/src/main/java/example/UseHMACSHA2_1.java | package example;
import javax.crypto.*;
import java.security.*;
import javax.crypto.spec.*;
public final class UseHMACSHA2_1 {
static String[] HMACs = {"HmacSHA224","HmacSHA256","HmacSHA384","HmacSHA512"};
public static void main(String[] args) throws Exception {
try {
for (int i = 0; i < 4; i++) {
KeyGenerator kg = KeyGenerator.getInstance(HMACs[i], "SunJCE");
SecretKey sk = kg.generateKey();
Mac mac = Mac.getInstance(HMACs[i], "SunJCE");
mac.init(sk);
String msg = "This is a demo msg";
mac.update(msg.getBytes());
byte[] result = mac.doFinal();
byte[] key2 = sk.getEncoded();
SecretKeySpec ks = new SecretKeySpec(key2, HMACs[i]);
Mac mac2 = Mac.getInstance(HMACs[i], "SunJCE");
mac2.init(ks);
mac2.update(msg.getBytes());
byte[] result2 = mac2.doFinal();
}
} catch (NoSuchAlgorithmException |
InvalidKeyException |
IllegalStateException e) {}
}
}
| 1,067 | 28.666667 | 81 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecurePadding/src/main/java/example/OAEP_2048x256_1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class OAEP_2048x256_1 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 256;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA256;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA-256", "MGF1",
mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] ptA = "This is a demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] ptB = c.doFinal(ct);
}
}
| 1,349 | 29 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecurePadding/src/main/java/example/OAEP_2048x256_2.java | package example;
import javax.crypto.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
public final class OAEP_2048x256_2 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 256;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
Cipher c = Cipher.getInstance("RSA/None/OAEPwithSHA256andMGF1Padding","BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk);
byte[] ptA = "This is a demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk);
byte[] ptB = c.doFinal(ct);
}
}
| 1,077 | 27.368421 | 80 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecurePadding/src/main/java/example/OAEP_2048x384_1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class OAEP_2048x384_1 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 384;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA384;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA-384", "MGF1",
mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] ptA = "This is a demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] ptB = c.doFinal(ct);
}
}
| 1,350 | 29.022222 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecurePadding/src/main/java/example/OAEP_2048x384_2.java | package example;
import javax.crypto.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
public final class OAEP_2048x384_2 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 384;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
Cipher c = Cipher.getInstance("RSA/None/OAEPwithSHA384andMGF1Padding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk);
byte[] ptA = "This is a demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk);
byte[] ptB = c.doFinal(ct);
}
}
| 1,078 | 27.394737 | 81 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecurePadding/src/main/java/example/OAEP_2048x512_1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class OAEP_2048x512_1 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 512;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA512;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA-512", "MGF1",
mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] ptA = "This is a demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] ptB = c.doFinal(ct);
}
}
| 1,350 | 29.704545 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecurePadding/src/main/java/example/OAEP_2048x512_2.java | package example;
import javax.crypto.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
public final class OAEP_2048x512_2 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 512;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
Cipher c = Cipher.getInstance("RSA/None/OAEPwithSHA512andMGF1Padding","BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk);
byte[] ptA = "This is a demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(ptA);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk);
byte[] ptB = c.doFinal(ct);
}
}
| 1,077 | 27.368421 | 80 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecurePaddingSign/src/main/java/example/PSSwSHA256Signature.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PSSwSHA256Signature {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(2048, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA256withRSAandMGF1", "BC");
byte[] m = "Testing RSA PSS w/ SHA256".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 870 | 25.393939 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecurePaddingSign/src/main/java/example/PSSwSHA384Signature.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.PSSParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PSSwSHA384Signature {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(2048, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA384withRSAandMGF1", "BC");
PSSParameterSpec spec = new PSSParameterSpec("SHA-384", "MGF1",
MGF1ParameterSpec.SHA384, 20, 1);
sig.setParameter(spec);
byte[] m = "Testing RSA PSS w/ SHA384".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 1,102 | 28.026316 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecurePaddingSign/src/main/java/example/PSSwSHA512Signature.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.PSSParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PSSwSHA512Signature {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(2048, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA512withRSAandMGF1", "BC");
PSSParameterSpec spec = new PSSParameterSpec("SHA-512", "MGF1",
MGF1ParameterSpec.SHA512, 20, 1);
sig.setParameter(spec);
byte[] m = "Testing RSA PSS w/ SHA512".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 1,102 | 28.026316 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureSymEnc/src/main/java/example/UseAEADwAES_GCM.java | package example;
import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
public final class UseAEADwAES_GCM {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
byte[] iv = new byte[128];
SecureRandom.getInstanceStrong().nextBytes(iv);
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
GCMParameterSpec gps = new GCMParameterSpec(128, iv);
Cipher c = Cipher.getInstance("AES/GCM/NoPadding", "BC");
c.init(Cipher.ENCRYPT_MODE, k, gps);
byte[] ptA = "This is a demo text".getBytes();
c.updateAAD("AAD is not encripted".getBytes());
byte[] ciphertext = c.doFinal(ptA);
c.init(Cipher.DECRYPT_MODE, k, gps);
c.updateAAD("AAD is not encripted".getBytes());
boolean ok = true;
byte[] ptB = null;
try {
ptB = c.doFinal(ciphertext);
} catch (AEADBadTagException e) {
ok = false;
}
}
} | 1,248 | 28.046512 | 75 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidInsecureSymEnc/src/main/java/example/UseAES_CTR.java | package example;
import java.nio.ByteBuffer;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.Arrays;
public final class UseAES_CTR {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException,
InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
byte[] ptA = ("non-static CTR").getBytes();
byte[] prefixCTR = new byte[8];
SecureRandom.getInstanceStrong().nextBytes(prefixCTR);
byte[] ictr = CTR.create();
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
Cipher enc = Cipher.getInstance("AES/CTR/NoPadding", "BC");
Cipher dec = Cipher.getInstance("AES/CTR/NoPadding", "BC");
byte[] ct;
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(ictr));
ct = enc.doFinal(ptA);
byte[] ctr = enc.getIV();
dec.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(ctr));
byte[] ptB = dec.doFinal(ct);
for (int i = 0; i < 10; i++) {
ictr = CTR.increment();
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(ictr));
ct = enc.doFinal(ptA);
ctr = enc.getIV();
dec.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(ctr));
ptB = dec.doFinal(ct);
}
}
}
class CTR {
static byte[] prefixCTR = new byte[8];
static ByteBuffer sufixCTR = ByteBuffer.allocate(Long.BYTES);
static byte[] currentCounter;
static long l;
static byte[] increment() throws NoSuchAlgorithmException {
sufixCTR = ByteBuffer.allocate(Long.BYTES);
l = l + 1;
sufixCTR.putLong(l);
currentCounter = Arrays.concatenate(prefixCTR, sufixCTR.array());
return currentCounter;
}
static byte[] create() throws NoSuchAlgorithmException {
SecureRandom.getInstanceStrong().nextBytes(prefixCTR);
l = SecureRandom.getInstanceStrong().nextLong();
sufixCTR.putLong(l);
currentCounter = Arrays.concatenate(prefixCTR, sufixCTR.array());
return currentCounter;
}
}
| 2,699 | 30.034483 | 75 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidKeyReuseInStreams/src/main/java/example/DoNotReuseKeyStreamCipher1.java | package example;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class DoNotReuseKeyStreamCipher1 {
public static void main(String args[]) {
try {
Security.addProvider(new BouncyCastleProvider());
byte[][] M = {("first text").getBytes(),
("second text").getBytes()};
byte[][] iv = new byte[2][16];
byte[][] C = new byte[2][];
SecureRandom sr = SecureRandom.getInstanceStrong();
sr.nextBytes(iv[0]);
sr.nextBytes(iv[1]);
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
Cipher enc = Cipher.getInstance("AES/OFB/NoPadding", "BC");
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv[0]));
C[0] = enc.doFinal(M[0]);
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv[1]));
C[1] = enc.doFinal(M[1]);
} catch (NoSuchAlgorithmException | NoSuchProviderException |
NoSuchPaddingException | InvalidKeyException |
InvalidAlgorithmParameterException | IllegalBlockSizeException |
BadPaddingException ex) {}
}
}
| 1,247 | 29.439024 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidKeyReuseInStreams/src/main/java/example/DoNotReuseKeyStreamCipher2.java | package example;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class DoNotReuseKeyStreamCipher2 {
public static void main(String args[]) {
try {
Security.addProvider(new BouncyCastleProvider());
byte[][] M = {("first text").getBytes(),
("second text").getBytes()};
byte[][] iv = new byte[2][16];
byte[][] C = new byte[2][];
SecureRandom sr = SecureRandom.getInstanceStrong();
sr.nextBytes(iv[0]);
sr.nextBytes(iv[1]);
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
Cipher enc = Cipher.getInstance("AES/CFB/NoPadding", "BC");
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv[0]));
C[0] = enc.doFinal(M[0]);
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv[1]));
C[1] = enc.doFinal(M[1]);
} catch (NoSuchAlgorithmException | NoSuchProviderException |
NoSuchPaddingException | InvalidKeyException |
InvalidAlgorithmParameterException | IllegalBlockSizeException |
BadPaddingException ex) {}
}
}
| 1,211 | 29.3 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidKeyReuseInStreams/src/main/java/example/DoNotReuseKeyStreamCipher3.java | package example;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class DoNotReuseKeyStreamCipher3 {
public static void main(String args[]) {
try {
Security.addProvider(new BouncyCastleProvider());
byte[][] M = {("first text").getBytes(),
("second text").getBytes()};
byte[] iv1 = new byte[16];
byte[] iv2 = new byte[16];
byte[][] C = new byte[2][];
SecureRandom sr = SecureRandom.getInstanceStrong();
sr.nextBytes(iv1);
sr.nextBytes(iv2);
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
Cipher enc = Cipher.getInstance("AES/OFB/NoPadding", "BC");
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv1));
C[0] = enc.doFinal(M[0]);
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv2));
C[1] = enc.doFinal(M[1]);
} catch (NoSuchAlgorithmException | NoSuchProviderException |
NoSuchPaddingException | InvalidKeyException |
InvalidAlgorithmParameterException | IllegalBlockSizeException |
BadPaddingException ex) {}
}
}
| 1,232 | 29.073171 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidKeyReuseInStreams/src/main/java/example/DoNotReuseKeyStreamCipher4.java | package example;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class DoNotReuseKeyStreamCipher4 {
public static void main(String args[]) {
try {
Security.addProvider(new BouncyCastleProvider());
byte[][] M = {("first text").getBytes(),
("second text").getBytes()};
byte[][] iv = new byte[2][16];
byte[][] C = new byte[2][];
SecureRandom sr = SecureRandom.getInstanceStrong();
sr.nextBytes(iv[0]);
sr.nextBytes(iv[1]);
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
Cipher enc = Cipher.getInstance("AES/OFB/NoPadding", "BC");
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv[0]));
C[0] = enc.doFinal(M[0]);
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv[1]));
C[1] = enc.doFinal(M[1]);
} catch (NoSuchAlgorithmException | NoSuchProviderException |
NoSuchPaddingException | InvalidKeyException |
InvalidAlgorithmParameterException | IllegalBlockSizeException |
BadPaddingException ex) {}
}
}
| 1,210 | 30.051282 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidKeyReuseInStreams/src/main/java/example/DoNotReuseKeyStreamCipher5.java |
package example;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.*;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class DoNotReuseKeyStreamCipher5 {
public static void main(String args[]) {
try {
Security.addProvider(new BouncyCastleProvider());
byte[][] M = {("first text").getBytes(),
("second text").getBytes()};
byte[][] iv = new byte[2][16];
byte[][] C = new byte[2][];
SecureRandom sr = SecureRandom.getInstanceStrong();
sr.nextBytes(iv[0]);
sr.nextBytes(iv[1]);
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
Cipher enc = Cipher.getInstance("AES/CFB/NoPadding", "BC");
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv[0]));
C[0] = enc.doFinal(M[0]);
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv[1]));
C[1] = enc.doFinal(M[1]);
} catch (NoSuchAlgorithmException | NoSuchProviderException |
NoSuchPaddingException | InvalidKeyException |
InvalidAlgorithmParameterException | IllegalBlockSizeException |
BadPaddingException ex) {}
}
}
| 1,227 | 30.487179 | 77 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidSideChannels/src/main/java/example/CompareHashesInConstantTime1.java | package example;
import javax.crypto.*;
import java.security.*;
public final class CompareHashesInConstantTime1 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException {
MessageDigest md = MessageDigest.getInstance("SHA-512","SUN");
boolean ok;
long t1, t2;
long t[] = new long[64];
md.reset();
byte[] hash1 = md.digest("demo text".getBytes());
for (int j = 0; j < 1; j++) {
for (int i = 0; i < t.length; i++) {
md.reset();
byte[] hash2 = md.digest("demo text".getBytes());
hash2[i] = (byte) (hash2[i] ^ 0x01);
t1 = System.nanoTime();
ok = MessageDigest.isEqual(hash2, hash1);
t2 = System.nanoTime();
t[i] = t2 - t1;
}
}
}
}
| 890 | 26 | 75 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidSideChannels/src/main/java/example/CompareHashesInConstantTime2.java |
package example;
import javax.crypto.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
import org.bouncycastle.util.Arrays;
public final class CompareHashesInConstantTime2 {
public static void main(String args[]) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException {
Security.addProvider(new BouncyCastleProvider());
MessageDigest md = MessageDigest.getInstance("SHA-512", "BC");
boolean ok;
long t1, t2;
long t[] = new long[64], tt[] = new long[64];
md.reset();
byte[] hash1 = md.digest("demo text".getBytes());
for (int j = 0; j < 1; j++) {
for (int i = 0; i < t.length; i++) {
md.reset();
byte[] hash2 = md.digest("demo text".getBytes());
hash2[i] = (byte) (hash2[i] ^ 0x01);
t1 = System.nanoTime();
ok = MessageDigest.isEqual(hash2, hash1);
t2 = System.nanoTime();
t[i] = t2 - t1;
}
for (int i = 0; i < t.length; i++) {
md.reset();
byte[] hash2 = md.digest("demo text".getBytes());
hash2[i] = (byte) (hash2[i] ^ 0x01);
t1 = System.nanoTime();
ok = Arrays.constantTimeAreEqual(hash2, hash1);
t2 = System.nanoTime();
tt[i] = t2 - t1;
}
}
}
}
| 1,364 | 27.4375 | 75 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidStatisticPRNG/src/main/java/example/DoNotUseClassRandom1.java | package example;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
public final class DoNotUseClassRandom1 {
public static void main(String[] args) {
try {
SecureRandom r1 = SecureRandom.getInstance("SHA1PRNG","SUN");
SecureRandom r2 = SecureRandom.getInstance("SHA1PRNG","SUN");
} catch (NoSuchAlgorithmException | NoSuchProviderException e) {}
}
}
| 464 | 26.352941 | 69 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidStatisticPRNG/src/main/java/example/DoNotUseClassRandom2.java | package example;
import java.security.SecureRandom;
public final class DoNotUseClassRandom2 {
public static void main(String[] args) {
try {
SecureRandom r1 = SecureRandom.getInstanceStrong();
SecureRandom r2 = SecureRandom.getInstanceStrong();
} catch (Exception e) {}
}
}
| 311 | 18.5 | 57 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidStatisticPRNG/src/main/java/example/DoNotUseClassRandom3.java | package example;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
public final class DoNotUseClassRandom3 {
public static void main(String[] args) {
try {
SecureRandom r1 = SecureRandom.getInstance("NativePRNG","SUN");
SecureRandom r2 = SecureRandom.getInstance("NativePRNG","SUN");
} catch (NoSuchAlgorithmException | NoSuchProviderException e) {}
}
}
| 469 | 25.111111 | 69 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/avoidStatisticPRNG/src/main/java/example/DoNotUseClassRandom4.java | package example;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
public final class DoNotUseClassRandom4 {
public static void main(String[] args) {
try {
SecureRandom r1 = SecureRandom.getInstance("Windows-PRNG","SunMSCAPI");
SecureRandom r2 = SecureRandom.getInstance("Windows-PRNG","SunMSCAPI");
} catch (NoSuchAlgorithmException | NoSuchProviderException e) {}
}
}
| 485 | 26 | 77 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/completeValidation/src/main/java/example/SSLClientCertPathCRLValidation.java | package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.NoSuchAlgorithmException;
import java.security.Principal;
import java.security.PublicKey;
import java.security.cert.CertPath;
import java.security.cert.CertPathValidator;
import java.security.cert.CertPathValidatorException;
import java.security.cert.CertStore;
import java.security.cert.CertStoreParameters;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.CollectionCertStoreParameters;
import java.security.cert.PKIXCertPathValidatorResult;
import java.security.cert.PKIXParameters;
import java.security.cert.PKIXRevocationChecker;
import java.security.cert.PolicyNode;
import java.security.cert.TrustAnchor;
import java.security.cert.X509CRL;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
import javax.net.ssl.*;
public final class SSLClientCertPathCRLValidation {
public static void main(String[] args) throws Exception {
SSLSocket socket = null;
boolean ok = true;
try {
SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory.getDefault();
socket = (SSLSocket) factory.createSocket("www.google.com", 443);
socket.startHandshake();
SSLSession session = socket.getSession();
Principal peerPrincipal = session.getPeerPrincipal();
Certificate[] certs = session.getPeerCertificates();
X509Certificate[] x509certs = new X509Certificate[certs.length - 1];
for (int i = 0; i < certs.length - 1; i++) {
x509certs[i] = (X509Certificate) certs[i];
}
X509Certificate anchor = (X509Certificate) certs[certs.length - 1];
List l = Arrays.asList(x509certs);
CertificateFactory cf = CertificateFactory.getInstance("X.509", "SUN");
CertPath cp = cf.generateCertPath(l);
TrustAnchor ta = new TrustAnchor(anchor, null);
PKIXParameters params = new PKIXParameters(Collections.singleton(ta));
CertPathValidator cpv = CertPathValidator.getInstance("PKIX", "SUN");
PKIXRevocationChecker rc = (PKIXRevocationChecker) cpv.getRevocationChecker();
rc.setOptions(EnumSet.of(PKIXRevocationChecker.Option.SOFT_FAIL));
rc.setOptions(EnumSet.of(PKIXRevocationChecker.Option.NO_FALLBACK));
rc.setOptions(EnumSet.of(PKIXRevocationChecker.Option.ONLY_END_ENTITY));
rc.setOptions(EnumSet.of(PKIXRevocationChecker.Option.PREFER_CRLS));
params.addCertPathChecker(rc);
X509CRL crl = null;
List list = new ArrayList();
list.add(crl);
CertStoreParameters csp = new CollectionCertStoreParameters(list);
CertStore store = CertStore.getInstance("Collection", csp);
params.addCertStore(store);
PKIXCertPathValidatorResult cpvr = (PKIXCertPathValidatorResult) cpv.validate(cp, params);
PolicyNode policyTree = cpvr.getPolicyTree();
PublicKey subjectPK = cpvr.getPublicKey();
} catch (CertificateException | InvalidAlgorithmParameterException | NoSuchAlgorithmException
| CertPathValidatorException e) {
ok = false;
}
}
}
| 3,149 | 37.414634 | 95 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/completeValidation/src/main/java/example/SSLClientCompleteValidation.java | package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.NoSuchAlgorithmException;
import java.security.Principal;
import java.security.PublicKey;
import java.security.cert.CertPath;
import java.security.cert.CertPathValidator;
import java.security.cert.CertPathValidatorException;
import java.security.cert.CertStore;
import java.security.cert.CertStoreParameters;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.CollectionCertStoreParameters;
import java.security.cert.PKIXCertPathValidatorResult;
import java.security.cert.PKIXParameters;
import java.security.cert.PKIXRevocationChecker;
import java.security.cert.PolicyNode;
import java.security.cert.TrustAnchor;
import java.security.cert.X509CRL;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
import javax.net.ssl.*;
public final class SSLClientCompleteValidation {
public static void main(String[] args) throws Exception {
SSLSocket socket = null;
boolean ok = true;
try {
SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory.getDefault();
socket = (SSLSocket) factory.createSocket("www.google.com", 443);
socket.startHandshake();
SSLSession session = socket.getSession();
Principal peerPrincipal = session.getPeerPrincipal();
Certificate[] peerCertificates = session.getPeerCertificates();
if (peerCertificates != null && peerCertificates.length >= 2) {
((X509Certificate) peerCertificates[0]).checkValidity();
peerCertificates[0].verify(peerCertificates[1].getPublicKey());
} else {
throw new CertificateException("Unable to verify certificate");
}
Certificate[] certs = session.getPeerCertificates();
X509Certificate[] x509certs = new X509Certificate[certs.length - 1];
for (int i = 0; i < certs.length - 1; i++) {
x509certs[i] = (X509Certificate) certs[i];
}
X509Certificate anchor = (X509Certificate) certs[certs.length - 1];
List l = Arrays.asList(x509certs);
CertificateFactory cf = CertificateFactory.getInstance("X.509", "SUN");
CertPath cp = cf.generateCertPath(l);
TrustAnchor ta = new TrustAnchor(anchor, null);
PKIXParameters params = new PKIXParameters(Collections.singleton(ta));
CertPathValidator cpv = CertPathValidator.getInstance("PKIX", "SUN");
PKIXRevocationChecker rc = (PKIXRevocationChecker) cpv.getRevocationChecker();
rc.setOptions(EnumSet.of(PKIXRevocationChecker.Option.SOFT_FAIL));
rc.setOptions(EnumSet.of(PKIXRevocationChecker.Option.NO_FALLBACK));
rc.setOptions(EnumSet.of(PKIXRevocationChecker.Option.ONLY_END_ENTITY));
rc.setOptions(EnumSet.of(PKIXRevocationChecker.Option.PREFER_CRLS));
params.addCertPathChecker(rc);
X509CRL crl = null;
List list = new ArrayList();
list.add(crl);
CertStoreParameters csp = new CollectionCertStoreParameters(list);
CertStore store = CertStore.getInstance("Collection", csp);
params.addCertStore(store);
PKIXCertPathValidatorResult cpvr = (PKIXCertPathValidatorResult) cpv.validate(cp, params);
PolicyNode policyTree = cpvr.getPolicyTree();
PublicKey subjectPK = cpvr.getPublicKey();
} catch (CertificateException | InvalidAlgorithmParameterException | NoSuchAlgorithmException
| CertPathValidatorException e) {
ok = false;
}
}
}
| 3,498 | 36.623656 | 95 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/completeValidation/src/main/java/example/SSLClientHostDateCertValidation.java | package example;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Principal;
import java.security.SignatureException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateNotYetValidException;
import java.security.cert.X509Certificate;
import javax.net.ssl.*;
public final class SSLClientHostDateCertValidation {
public static void main(String[] args) throws Exception {
SSLSocket socket = null;
boolean ok = true;
try {
SSLSocketFactory factory = (SSLSocketFactory) SSLSocketFactory.getDefault();
socket = (SSLSocket) factory.createSocket("www.google.com", 443);
socket.startHandshake();
SSLSession session = socket.getSession();
Principal peerPrincipal = session.getPeerPrincipal();
Certificate[] peerCertificates = session.getPeerCertificates();
if (peerCertificates != null && peerCertificates.length >= 2) {
((X509Certificate) peerCertificates[0]).checkValidity();
peerCertificates[0].verify(peerCertificates[1].getPublicKey());
} else {
throw new CertificateException("Unable to verify certificate");
}
} catch (CertificateExpiredException | CertificateNotYetValidException | NoSuchAlgorithmException
| InvalidKeyException | NoSuchProviderException | SignatureException e) {
ok = false;
} catch (CertificateException e) {
ok = false;
}
}
}
| 1,551 | 32.021277 | 99 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/completeValidation/src/main/java/example/ValidateDateIssuerUser.java | package example;
import java.math.BigInteger;
import java.security.InvalidKeyException;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.Security;
import java.security.SignatureException;
import java.security.cert.CertificateException;
import java.security.cert.CertificateExpiredException;
import java.security.cert.CertificateNotYetValidException;
import java.security.cert.X509Certificate;
import java.util.Date;
import javax.security.auth.x500.X500Principal;
import org.bouncycastle.asn1.x500.X500Name;
import org.bouncycastle.asn1.x509.BasicConstraints;
import org.bouncycastle.asn1.x509.Extension;
import org.bouncycastle.asn1.x509.KeyUsage;
import org.bouncycastle.cert.CertIOException;
import org.bouncycastle.cert.X509v1CertificateBuilder;
import org.bouncycastle.cert.X509v3CertificateBuilder;
import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
import org.bouncycastle.cert.jcajce.JcaX509ExtensionUtils;
import org.bouncycastle.cert.jcajce.JcaX509v1CertificateBuilder;
import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.operator.ContentSigner;
import org.bouncycastle.operator.OperatorCreationException;
import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
public final class ValidateDateIssuerUser {
private static final int oneSecond = 1000;
private static final int oneMinute = oneSecond * 60;
private static final int oneHour = oneMinute * 60;
private static final int oneDay = oneHour * 24;
private static final int oneWeek = oneDay * 7;
private static final int validity = oneWeek;
private static int serialNumberCounter = 1;
public static boolean validate(X509Certificate cert, X509Certificate ca, X500Principal issuer, X500Principal subj,
Date date) {
boolean ok = false;
try {
if (date != null) {
cert.checkValidity(date);
} else {
cert.checkValidity();
}
ok = true;
} catch (CertificateExpiredException | CertificateNotYetValidException ex) {
ok = false;
}
if (ok) {
try {
ok = false;
cert.verify(ca.getPublicKey());
ok = true;
} catch (CertificateException ex) {
ok = false;
} catch (NoSuchAlgorithmException | InvalidKeyException | NoSuchProviderException | SignatureException ex) {
ok = false;
}
}
if (ok) {
ok = false;
if (cert.getIssuerX500Principal().equals(issuer)) {
ok = true;
} else {
ok = false;
}
if (ok && cert.getSubjectX500Principal().equals(subj)) {
ok = true;
} else {
ok = false;
}
}
return ok;
}
public static void main(String[] args) {
Security.addProvider(new BouncyCastleProvider());
try {
KeyPair rkp = genRSAKeyPair();
X509Certificate root = buildSelfSignedCert(rkp);
KeyPair mkp = genRSAKeyPair();
X509Certificate middle = buildMiddleCert(mkp.getPublic(), "CN=Intermediate CA Certificate",
rkp.getPrivate(), root);
KeyPair ekp = genRSAKeyPair();
X509Certificate user = buildEndCert(ekp.getPublic(), "CN=End User Certificate", mkp.getPrivate(), middle);
X500Principal issuer = new X500Principal("CN=Root Certificate");
X500Principal subj1 = new X500Principal("CN=Intermediate CA Certificate");
X500Principal subj2 = new X500Principal("CN=End User Certificate");
boolean ok = false;
ok = validate(user, middle, subj1, subj2, null);
} catch (Exception ex) {
}
}
public static KeyPair genRSAKeyPair() throws Exception {
KeyPairGenerator kpGen = KeyPairGenerator.getInstance("RSA", "BC");
kpGen.initialize(2048, new SecureRandom());
return kpGen.generateKeyPair();
}
public static X509Certificate buildSelfSignedCert(KeyPair keyPair) throws Exception {
X509v1CertificateBuilder certBldr = new JcaX509v1CertificateBuilder(new X500Name("CN=Root Certificate"),
BigInteger.valueOf(1), new Date(System.currentTimeMillis()),
new Date(System.currentTimeMillis() + oneWeek), new X500Name("CN=Root Certificate"),
keyPair.getPublic());
JcaContentSignerBuilder jcsb = new JcaContentSignerBuilder("SHA256withRSA");
jcsb.setProvider("BC");
ContentSigner signer = jcsb.build(keyPair.getPrivate());
JcaX509CertificateConverter jX509c = new JcaX509CertificateConverter();
jX509c.setProvider("BC");
X509Certificate cert = jX509c.getCertificate(certBldr.build(signer));
return cert;
}
public static X509Certificate buildMiddleCert(PublicKey pk, String cn, PrivateKey caKey, X509Certificate cac)
throws NoSuchAlgorithmException, CertIOException, OperatorCreationException, CertificateException {
X509Certificate cert = null;
X509v3CertificateBuilder cb = new JcaX509v3CertificateBuilder(cac.getSubjectX500Principal(),
BigInteger.valueOf(serialNumberCounter++), new Date(System.currentTimeMillis()),
new Date(System.currentTimeMillis() + validity), new X500Principal(cn), pk);
JcaX509ExtensionUtils utils;
utils = new JcaX509ExtensionUtils();
cb.addExtension(Extension.authorityKeyIdentifier, false, utils.createAuthorityKeyIdentifier(cac));
cb.addExtension(Extension.subjectKeyIdentifier, false, utils.createSubjectKeyIdentifier(pk));
cb.addExtension(Extension.basicConstraints, true, new BasicConstraints(0));
cb.addExtension(Extension.keyUsage, true,
new KeyUsage(KeyUsage.digitalSignature | KeyUsage.keyCertSign | KeyUsage.cRLSign));
JcaContentSignerBuilder jcsb = new JcaContentSignerBuilder("SHA256withRSA");
jcsb.setProvider("BC");
ContentSigner signer = jcsb.build(caKey);
JcaX509CertificateConverter jX509c = new JcaX509CertificateConverter();
jX509c.setProvider("BC");
cert = jX509c.getCertificate(cb.build(signer));
return cert;
}
public static X509Certificate buildEndCert(PublicKey pk, String cn, PrivateKey caKey, X509Certificate ca) throws NoSuchAlgorithmException, CertIOException, OperatorCreationException, CertificateException {
X509Certificate cert = null;
X509v3CertificateBuilder cb = new JcaX509v3CertificateBuilder(ca.getSubjectX500Principal(),
BigInteger.valueOf(serialNumberCounter++), new Date(System.currentTimeMillis()),
new Date(System.currentTimeMillis() + validity), new X500Principal(cn), pk);
JcaX509ExtensionUtils utils;
utils = new JcaX509ExtensionUtils();
cb.addExtension(Extension.authorityKeyIdentifier, false, utils.createAuthorityKeyIdentifier(ca));
cb.addExtension(Extension.subjectKeyIdentifier, false, utils.createSubjectKeyIdentifier(pk));
cb.addExtension(Extension.basicConstraints, true, new BasicConstraints(false));
cb.addExtension(Extension.keyUsage, true, new KeyUsage(KeyUsage.digitalSignature | KeyUsage.keyEncipherment));
JcaContentSignerBuilder jcsb = new JcaContentSignerBuilder("SHA256withRSA");
jcsb.setProvider("BC");
ContentSigner signer = jcsb.build(caKey);
JcaX509CertificateConverter jX509c = new JcaX509CertificateConverter();
jX509c.setProvider("BC");
cert = jX509c.getCertificate(cb.build(signer));
return cert;
}
}
| 7,188 | 36.442708 | 206 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignDSAandECDSA/src/main/java/example/BC_128bits_DSA3072xSHA256.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class BC_128bits_DSA3072xSHA256 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA", "BC");
kpg.initialize(3072, new SecureRandom());
Signature sign1 = Signature.getInstance("SHA256WithDSA", "BC");
KeyPair kp1 = kpg.generateKeyPair();
sign1.initSign(kp1.getPrivate(), new SecureRandom());
byte[] doc = "this is a demo text".getBytes();
sign1.update(doc);
byte[] signed1 = sign1.sign();
Signature verfier1 = Signature.getInstance("SHA256WithDSA", "BC");
verfier1.initVerify(kp1.getPublic());
verfier1.update(doc);
boolean ok = verfier1.verify(signed1);
}
}
| 1,050 | 29.911765 | 74 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignDSAandECDSA/src/main/java/example/BC_ECDSAprime192.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.ECGenParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class BC_ECDSAprime192 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kpg = KeyPairGenerator.getInstance("ECDSA", "BC");
ECGenParameterSpec ec = new ECGenParameterSpec("prime192v1");
kpg.initialize(ec, new SecureRandom());
Signature signer = Signature.getInstance("SHA256WithECDSA", "BC");
KeyPair kp = kpg.generateKeyPair();
signer.initSign(kp.getPrivate(), new SecureRandom());
byte[] doc = "this is a demo text".getBytes();
signer.update(doc);
byte[] signature = signer.sign();
Signature verifier = Signature.getInstance("SHA256WithECDSA", "BC");
verifier.initVerify(kp.getPublic());
verifier.update(doc);
boolean ok = verifier.verify(signature);
}
}
| 1,167 | 29.736842 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignDSAandECDSA/src/main/java/example/BC_ECDSAprime239.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.ECGenParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class BC_ECDSAprime239 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kpg = KeyPairGenerator.getInstance("ECDSA", "BC");
ECGenParameterSpec ec = new ECGenParameterSpec("prime239v1");
kpg.initialize(ec, new SecureRandom());
Signature signer = Signature.getInstance("SHA256WithECDSA", "BC");
KeyPair kp = kpg.generateKeyPair();
signer.initSign(kp.getPrivate(), new SecureRandom());
byte[] doc = "this is a demo text".getBytes();
signer.update(doc);
byte[] signature = signer.sign();
Signature verifier = Signature.getInstance("SHA256WithECDSA", "BC");
verifier.initVerify(kp.getPublic());
verifier.update(doc);
boolean ok = verifier.verify(signature);
}
}
| 1,167 | 29.736842 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignDSAandECDSA/src/main/java/example/BC_ECDSAprime256.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.ECGenParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class BC_ECDSAprime256 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kpg = KeyPairGenerator.getInstance("ECDSA", "BC");
ECGenParameterSpec ec = new ECGenParameterSpec("prime256v1");
kpg.initialize(ec, new SecureRandom());
Signature signer = Signature.getInstance("SHA256WithECDSA", "BC");
KeyPair kp = kpg.generateKeyPair();
signer.initSign(kp.getPrivate(), new SecureRandom());
byte[] doc = "this is a demo text".getBytes();
signer.update(doc);
byte[] signature = signer.sign();
Signature verifier = Signature.getInstance("SHA256WithECDSA", "BC");
verifier.initVerify(kp.getPublic());
verifier.update(doc);
boolean ok = verifier.verify(signature);
}
}
| 1,167 | 29.736842 | 76 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignDSAandECDSA/src/main/java/example/RandomMessageNonceECDSA.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Signature;
import java.security.spec.ECGenParameterSpec;
import org.bouncycastle.util.Arrays;
public final class RandomMessageNonceECDSA {
public static void main(String[] args) throws Exception {
ECGenParameterSpec ecps = new ECGenParameterSpec("secp256r1");
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "SunEC");
kpg.initialize(ecps);
KeyPair kp = kpg.generateKeyPair();
SecureRandom sr1 = SecureRandom.getInstanceStrong();
byte[] seed = sr1.generateSeed(24);
sr1.setSeed(seed);
Signature signer1 = Signature.getInstance("SHA256withECDSA", "SunEC");
signer1.initSign(kp.getPrivate(), sr1);
byte[] doc = "this is a demo text".getBytes();
signer1.update(doc);
byte[] sign1 = signer1.sign();
SecureRandom sr2 = SecureRandom.getInstanceStrong();
sr2.setSeed(seed);
Signature signer2 = Signature.getInstance("SHA256withECDSA", "SunEC");
signer2.initSign(kp.getPrivate(), sr2);
doc = "this is a demo text".getBytes();
signer2.update(doc);
byte[] sign2 = signer2.sign();
boolean ok = Arrays.areEqual(sign1, sign2);
}
}
| 1,222 | 27.44186 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignDSAandECDSA/src/main/java/example/SUN_112bits_DSA2048wSHA256.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Signature;
public final class SUN_112bits_DSA2048wSHA256 {
public static void main(String[] args) throws Exception {
KeyPairGenerator kpg = KeyPairGenerator.getInstance("DSA", "SUN");
kpg.initialize(2048, new SecureRandom());
Signature sign1 = Signature.getInstance("SHA256WithDSA", "SUN");
KeyPair kp = kpg.generateKeyPair();
sign1.initSign(kp.getPrivate(), new SecureRandom());
byte[] doc = "this is a demo text".getBytes();
sign1.update(doc);
byte[] signed = sign1.sign();
Signature verifier = Signature.getInstance("SHA256WithDSA", "SUN");
verifier.initVerify(kp.getPublic());
verifier.update(doc);
boolean ok = verifier.verify(signed);
}
}
| 822 | 25.548387 | 69 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignDSAandECDSA/src/main/java/example/SUN_112bits_ECDSA224wSHA224.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Signature;
public final class SUN_112bits_ECDSA224wSHA224 {
public static void main(String[] args) throws Exception {
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "SunEC");
kpg.initialize(224, new SecureRandom());
Signature signer = Signature.getInstance("SHA224WithECDSA", "SunEC");
KeyPair kp = kpg.generateKeyPair();
signer.initSign(kp.getPrivate(), new SecureRandom());
byte[] doc = "this is a demo text".getBytes();
signer.update(doc);
byte[] signed = signer.sign();
Signature verifier = Signature.getInstance("SHA224WithECDSA", "SunEC");
verifier.initVerify(kp.getPublic());
verifier.update(doc);
boolean ok = verifier.verify(signed);
}
}
| 835 | 25.967742 | 73 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignDSAandECDSA/src/main/java/example/SUN_128bits_ECDSA256wSHA256.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Signature;
public final class SUN_128bits_ECDSA256wSHA256 {
public static void main(String[] args) throws Exception {
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "SunEC");
kpg.initialize(256, new SecureRandom());
Signature sing = Signature.getInstance("SHA256WithECDSA", "SunEC");
KeyPair kp = kpg.generateKeyPair();
sing.initSign(kp.getPrivate(), new SecureRandom());
byte[] doc = "this is a demo text".getBytes();
sing.update(doc);
byte[] signed = sing.sign();
Signature verifier = Signature.getInstance("SHA256WithECDSA", "SunEC");
verifier.initVerify(kp.getPublic());
verifier.update(doc);
boolean ok = verifier.verify(signed);
}
}
| 827 | 25.709677 | 73 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignDSAandECDSA/src/main/java/example/SUN_192bits_ECDSA384wSHA384.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Signature;
public final class SUN_192bits_ECDSA384wSHA384 {
public static void main(String[] args) throws Exception {
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "SunEC");
kpg.initialize(384, new SecureRandom());
Signature sign = Signature.getInstance("SHA384WithECDSA", "SunEC");
KeyPair kp = kpg.generateKeyPair();
sign.initSign(kp.getPrivate(), new SecureRandom());
byte[] doc = "demo text".getBytes();
sign.update(doc);
byte[] signed = sign.sign();
Signature verifier = Signature.getInstance("SHA384WithECDSA", "SunEC");
verifier.initVerify(kp.getPublic());
verifier.update(doc);
boolean ok = verifier.verify(signed);
}
}
| 817 | 25.387097 | 73 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignDSAandECDSA/src/main/java/example/SUN_256bits_ECDSA571wSHA512.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Signature;
public final class SUN_256bits_ECDSA571wSHA512 {
public static void main(String[] args) throws Exception {
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "SunEC");
kpg.initialize(571, new SecureRandom());
Signature sign = Signature.getInstance("SHA512WithECDSA", "SunEC");
KeyPair kp = kpg.generateKeyPair();
sign.initSign(kp.getPrivate(), new SecureRandom());
byte[] doc = "demo text".getBytes();
sign.update(doc);
byte[] signed = sign.sign();
Signature verifier = Signature.getInstance("SHA512WithECDSA", "SunEC");
verifier.initVerify(kp.getPublic());
verifier.update(doc);
boolean ok = verifier.verify(signed);
}
}
| 817 | 25.387097 | 73 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PKCS1_112bitsSign2048xSHA256_1.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PKCS1_112bitsSign2048xSHA256_1 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(2048, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA256withRSA", "BC");
byte[] m = "Testing RSA PKCS1".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 866 | 25.272727 | 68 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PKCS1_112bitsSign2048xSHA256_2.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PKCS1_112bitsSign2048xSHA256_2 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(2048, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA256withRSA", "BC");
byte[] m = "Testing RSA PKCS1".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 866 | 25.272727 | 68 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PKCS1_128bitsSign3072xSHA256_1.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PKCS1_128bitsSign3072xSHA256_1 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(3072, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA256withRSA", "BC");
byte[] m = "Testing RSA PKCS1".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 866 | 25.272727 | 68 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PKCS1_128bitsSign3072xSHA256_2.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PKCS1_128bitsSign3072xSHA256_2 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(3072, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA256withRSA", "BC");
byte[] m = "Testing RSA PKCS1".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 866 | 25.272727 | 68 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PKCS1_192bitsSign7680xSHA384_1.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PKCS1_192bitsSign7680xSHA384_1 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(7680, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA384withRSA", "BC");
byte[] m = "Testing RSA PKCS1".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 866 | 25.272727 | 68 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PKCS1_192bitsSign7680xSHA384_2.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PKCS1_192bitsSign7680xSHA384_2 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(7680, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA384withRSA", "BC");
byte[] m = "Testing RSA PKCS1".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 866 | 25.272727 | 68 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PSS_112bitsSign2048xSHA256_1.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.PSSParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PSS_112bitsSign2048xSHA256_1 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(2048, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA256withRSAandMGF1", "BC");
sig.setParameter(PSSParameterSpec.DEFAULT);
byte[] m = "Testing weak RSA-PSS".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 966 | 26.628571 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PSS_112bitsSign2048xSHA256_2.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.PSSParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PSS_112bitsSign2048xSHA256_2 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(2048, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA256withRSAandMGF1", "BC");
PSSParameterSpec spec = new PSSParameterSpec("SHA-256", "MGF1",
MGF1ParameterSpec.SHA256, 20, 1);
sig.setParameter(spec);
byte[] m = "Testing weak RSA-PSS".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 1,106 | 28.131579 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PSS_128bitsSign3072xSHA256_1.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.PSSParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PSS_128bitsSign3072xSHA256_1 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(3072, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA256withRSAandMGF1", "BC");
sig.setParameter(PSSParameterSpec.DEFAULT);
byte[] m = "Testing weak RSA-PSS".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 966 | 26.628571 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PSS_128bitsSign3072xSHA256_2.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.PSSParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PSS_128bitsSign3072xSHA256_2 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(3072, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA256withRSAandMGF1", "BC");
PSSParameterSpec spec = new PSSParameterSpec("SHA-256", "MGF1",
MGF1ParameterSpec.SHA256, 20, 1);
sig.setParameter(spec);
byte[] m = "Testing weak RSA-PSS".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 1,106 | 28.131579 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PSS_192bitsSign7680xSHA384_1.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.PSSParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PSS_192bitsSign7680xSHA384_1 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(7680, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA384withRSAandMGF1", "BC");
sig.setParameter(PSSParameterSpec.DEFAULT);
byte[] m = "Testing weak RSA-PSS".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 966 | 26.628571 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/digSignRSA/src/main/java/example/PSS_192bitsSign7680xSHA384_2.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Security;
import java.security.Signature;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.PSSParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class PSS_192bitsSign7680xSHA384_2 {
public static void main(String[] args) throws Exception {
Security.addProvider(new BouncyCastleProvider());
KeyPairGenerator kg = KeyPairGenerator.getInstance("RSA", "BC");
kg.initialize(7680, new SecureRandom());
KeyPair kp = kg.generateKeyPair();
Signature sig = Signature.getInstance("SHA384withRSAandMGF1", "BC");
PSSParameterSpec spec = new PSSParameterSpec("SHA-384", "MGF1",
MGF1ParameterSpec.SHA384, 20, 1);
sig.setParameter(spec);
byte[] m = "Testing weak RSA-PSS".getBytes("UTF-8");
sig.initSign(kp.getPrivate(), new SecureRandom());
sig.update(m);
byte[] s = sig.sign();
sig.initVerify(kp.getPublic());
sig.update(m);
}
}
| 1,106 | 28.131579 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/doNotPrintSecrets/src/main/java/example/DoNotPrintDHPrivKey1.java | package example;
import java.security.*;
import java.security.spec.*;
import java.util.Arrays;
import javax.crypto.*;
public final class DoNotPrintDHPrivKey1 {
public static void main(String argv[]) {
try {
KeyPairGenerator kpg1 = KeyPairGenerator.getInstance("DH", "SunJCE");
kpg1.initialize(2048);
KeyPair kp1 = kpg1.generateKeyPair();
KeyAgreement ka1 = KeyAgreement.getInstance("DH", "SunJCE");
ka1.init(kp1.getPrivate());
byte[] pubKey1 = kp1.getPublic().getEncoded();
KeyFactory kf1 = KeyFactory.getInstance("DH", "SunJCE");
X509EncodedKeySpec x509ks = new X509EncodedKeySpec(pubKey1);
PublicKey apk1 = kf1.generatePublic(x509ks);
KeyPairGenerator kpg2 = KeyPairGenerator.getInstance("DH", "SunJCE");
kpg2.initialize(2048);
KeyPair kp2 = kpg2.generateKeyPair();
KeyAgreement ka2 = KeyAgreement.getInstance("DH", "SunJCE");
ka2.init(kp2.getPrivate());
byte[] pubKey2 = kp2.getPublic().getEncoded();
KeyFactory kf2 = KeyFactory.getInstance("DH", "SunJCE");
x509ks = new X509EncodedKeySpec(pubKey2);
PublicKey apk2 = kf2.generatePublic(x509ks);
ka1.doPhase(apk2, true);
byte[] genSec1 = ka1.generateSecret();
ka2.doPhase(apk1, true);
byte[] genSec2 = ka2.generateSecret();
if (!Arrays.equals(genSec1, genSec2)) {
throw new Exception("Shared secrets differ");
}
} catch (Exception e) {
}
}
}
| 1,388 | 27.9375 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/doNotPrintSecrets/src/main/java/example/DoNotPrintDHSecret1.java | package example;
import java.security.*;
import java.security.spec.*;
import java.util.Arrays;
import javax.crypto.*;
public final class DoNotPrintDHSecret1 {
public static void main(String argv[]) {
try {
KeyPairGenerator kpg1 = KeyPairGenerator.getInstance("DH", "SunJCE");
kpg1.initialize(2048);
KeyPair kp1 = kpg1.generateKeyPair();
KeyAgreement ka1 = KeyAgreement.getInstance("DH", "SunJCE");
ka1.init(kp1.getPrivate());
byte[] pubKey1 = kp1.getPublic().getEncoded();
KeyFactory kf1 = KeyFactory.getInstance("DH", "SunJCE");
X509EncodedKeySpec x509ks = new X509EncodedKeySpec(pubKey1);
PublicKey apk1 = kf1.generatePublic(x509ks);
KeyPairGenerator kpg2 = KeyPairGenerator.getInstance("DH", "SunJCE");
kpg2.initialize(2048);
KeyPair kp2 = kpg2.generateKeyPair();
KeyAgreement ka2 = KeyAgreement.getInstance("DH", "SunJCE");
ka2.init(kp2.getPrivate());
byte[] pubKey2 = kp2.getPublic().getEncoded();
KeyFactory kf2 = KeyFactory.getInstance("DH", "SunJCE");
x509ks = new X509EncodedKeySpec(pubKey2);
PublicKey apk2 = kf2.generatePublic(x509ks);
ka1.doPhase(apk2, true);
byte[] genSec1 = ka1.generateSecret();
ka2.doPhase(apk1, true);
byte[] genSec2 = ka2.generateSecret();
if (!Arrays.equals(genSec1, genSec2)) {
throw new Exception("Shared secrets differ");
}
} catch (Exception e) {
}
}
}
| 1,389 | 26.8 | 72 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/doNotPrintSecrets/src/main/java/example/DoNotPrintECDHPrivKey1.java | package example;
import java.security.*;
import java.security.spec.*;
import java.util.Arrays;
import javax.crypto.*;
public final class DoNotPrintECDHPrivKey1 {
public static void main(String argv[]) {
try {
KeyPairGenerator kpg1 = KeyPairGenerator.getInstance("EC", "SunEC");
kpg1.initialize(521);
KeyPair kp1 = kpg1.generateKeyPair();
KeyAgreement ka1 = KeyAgreement.getInstance("ECDH", "SunEC");
ka1.init(kp1.getPrivate());
byte[] pubKey1 = kp1.getPublic().getEncoded();
KeyFactory kf1 = KeyFactory.getInstance("EC", "SunEC");
X509EncodedKeySpec x509ks = new X509EncodedKeySpec(pubKey1);
PublicKey apk1 = kf1.generatePublic(x509ks);
KeyPairGenerator kpg2 = KeyPairGenerator.getInstance("EC", "SunEC");
kpg2.initialize(521);
KeyPair kp2 = kpg2.generateKeyPair();
KeyAgreement ka2 = KeyAgreement.getInstance("ECDH", "SunEC");
ka2.init(kp2.getPrivate());
byte[] pubKey2 = kp2.getPublic().getEncoded();
KeyFactory kf2 = KeyFactory.getInstance("EC", "SunEC");
x509ks = new X509EncodedKeySpec(pubKey2);
PublicKey apk2 = kf2.generatePublic(x509ks);
ka1.doPhase(apk2, true);
byte[] genSec1 = ka1.generateSecret();
ka2.doPhase(apk1, true);
byte[] genSec2 = ka2.generateSecret();
if (!Arrays.equals(genSec1, genSec2)) {
throw new Exception("Shared secrets differ");
}
} catch (Exception e) {
}
}
}
| 1,386 | 27.895833 | 71 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/doNotPrintSecrets/src/main/java/example/DoNotPrintECDHSecret1.java | package example;
import java.security.*;
import java.security.spec.*;
import java.util.Arrays;
import javax.crypto.*;
public final class DoNotPrintECDHSecret1 {
public static void main(String argv[]) {
try {
KeyPairGenerator kpg1 = KeyPairGenerator.getInstance("EC", "SunEC");
kpg1.initialize(521);
KeyPair kp1 = kpg1.generateKeyPair();
KeyAgreement ka1 = KeyAgreement.getInstance("ECDH", "SunEC");
ka1.init(kp1.getPrivate());
byte[] pubKey1 = kp1.getPublic().getEncoded();
KeyFactory kf1 = KeyFactory.getInstance("EC", "SunEC");
X509EncodedKeySpec x509ks = new X509EncodedKeySpec(pubKey1);
PublicKey apk1 = kf1.generatePublic(x509ks);
KeyPairGenerator kpg2 = KeyPairGenerator.getInstance("EC", "SunEC");
kpg2.initialize(521);
KeyPair kp2 = kpg2.generateKeyPair();
KeyAgreement ka2 = KeyAgreement.getInstance("ECDH", "SunEC");
ka2.init(kp2.getPrivate());
byte[] pubKey2 = kp2.getPublic().getEncoded();
KeyFactory kf2 = KeyFactory.getInstance("EC", "SunEC");
x509ks = new X509EncodedKeySpec(pubKey2);
PublicKey apk2 = kf2.generatePublic(x509ks);
ka1.doPhase(apk2, true);
byte[] genSec1 = ka1.generateSecret();
ka2.doPhase(apk1, true);
byte[] genSec2 = ka2.generateSecret();
if (!Arrays.equals(genSec1, genSec2)) {
throw new Exception("Shared secrets differ");
}
} catch (Exception e) {
}
}
}
| 1,385 | 27.875 | 71 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/doNotPrintSecrets/src/main/java/example/DoNotPrintECDSAPrivKey1.java | package example;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.SecureRandom;
import java.security.Signature;
public final class DoNotPrintECDSAPrivKey1 {
public static void main(String[] args) throws Exception {
KeyPairGenerator kpg = KeyPairGenerator.getInstance("EC", "SunEC");
kpg.initialize(571, new SecureRandom());
Signature sign = Signature.getInstance("SHA512WithECDSA", "SunEC");
KeyPair kp = kpg.generateKeyPair();
sign.initSign(kp.getPrivate(), new SecureRandom());
byte[] doc = "demo text".getBytes();
sign.update(doc);
byte[] signed = sign.sign();
Signature verifier = Signature.getInstance("SHA512WithECDSA", "SunEC");
verifier.initVerify(kp.getPublic());
verifier.update(doc);
boolean ok = verifier.verify(signed);
}
}
| 813 | 25.258065 | 73 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/doNotPrintSecrets/src/main/java/example/DoNotPrintPrivKey1.java | package example;
import javax.crypto.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
public final class DoNotPrintPrivKey1 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 256;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
Cipher c = Cipher.getInstance("RSA/None/OAEPwithSHA256andMGF1Padding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk);
byte[] pt1 = "demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(pt1);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk);
byte[] pt2 = c.doFinal(ct);
}
}
| 1,004 | 26.916667 | 101 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/doNotPrintSecrets/src/main/java/example/DoNotPrintSecKey1.java | package example;
import java.io.UnsupportedEncodingException;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class DoNotPrintSecKey1 {
public static void main(String args[]) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
BadPaddingException, IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException,
UnsupportedEncodingException {
Security.addProvider(new BouncyCastleProvider());
byte[] pt1 = ("demo text").getBytes("UTF-8");
byte[] iv = new byte[16];
SecureRandom.getInstanceStrong().nextBytes(iv);
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(128);
Key k = g.generateKey();
String aes = "AES/CTR/NoPadding";
Cipher enc = Cipher.getInstance(aes, "BC");
Cipher dec = Cipher.getInstance(aes, "BC");
byte[] ct;
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv));
ct = enc.doFinal(pt1);
dec.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(iv));
byte[] pt2 = dec.doFinal(ct);
dec.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(iv));
pt2 = dec.doFinal(ct);
}
}
| 1,644 | 31.254902 | 117 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/encryptThenHashOrMAC/src/main/java/example/EncryptThenHashCiphertextAndIV.java |
package example;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.IvParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.Arrays;
public final class EncryptThenHashCiphertextAndIV {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
byte[] iv = new byte[16];
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
SecureRandom.getInstanceStrong().nextBytes(iv);
Cipher c = Cipher.getInstance("AES/CTR/NoPadding", "BC");
MessageDigest md = MessageDigest.getInstance("SHA256", "BC");
byte[] pt1 = "demo text".getBytes(), X, Y;
boolean ok, ivo = false, corrupt = false;
String s = "Encrypt-then-Hash(EtH): hash of ciphertext + IV";
md.reset();
c.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv));
byte[] ct = c.doFinal(pt1);
byte[] ctPlusIV = ct.clone();
Arrays.concatenate(ctPlusIV, iv);
byte[] hash = md.digest(ctPlusIV);
if (ivo) {
X = "demo text 1".getBytes();
ct = "demo text 2".getBytes();
hash = md.digest(ct);
}
if (corrupt) {
ct[0] = (byte) ((byte) ct[0] ^ 0x01);
}
ctPlusIV = ct.clone();
Arrays.concatenate(ctPlusIV, iv);
ok = MessageDigest.isEqual(md.digest(ctPlusIV), hash);
if (ok) {
md.reset();
c.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(iv));
byte[] ptBeto = c.doFinal(ct);
}
}
}
| 1,633 | 27.666667 | 101 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/encryptThenHashOrMAC/src/main/java/example/EncryptThenMacCiphertextAndIV.java |
package example;
import java.security.*;
import javax.crypto.*;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.Arrays;
public final class EncryptThenMacCiphertextAndIV {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
byte[] iv = new byte[16], k2 = new byte[16];
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k1 = g.generateKey();
(new SecureRandom()).nextBytes(iv);
(new SecureRandom()).nextBytes(k2);
SecretKeySpec sks2 = new SecretKeySpec(k2, "HMACSHA256");
Cipher c = Cipher.getInstance("AES/CTR/NoPadding", "BC");
Mac m = Mac.getInstance("HMACSHA256", "BC");
byte[] pt1 = "demo text".getBytes(), X;
boolean ok, ivo = true;
String s = "demo text 2";
m.init(sks2);
c.init(Cipher.ENCRYPT_MODE, k1, new IvParameterSpec(iv));
byte[] ct = c.doFinal(pt1);
byte[] ctPlusIV = ct.clone();
Arrays.concatenate(ctPlusIV, iv);
byte[] tag = m.doFinal(ctPlusIV);
if (ivo) {
X = "demo text 3".getBytes();
ct = "demo text 4".getBytes();
}
ctPlusIV = ct.clone();
Arrays.concatenate(ctPlusIV, iv);
ok = MessageDigest.isEqual(m.doFinal(ctPlusIV), tag);
if (ok) {
m.init(sks2);
c.init(Cipher.DECRYPT_MODE, k1, new IvParameterSpec(iv));
byte[] pt2 = c.doFinal(ct);
}
}
}
| 1,616 | 28.944444 | 101 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/randomIV/src/main/java/example/UseRandomIVsForCBC.java | package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class UseRandomIVsForCBC {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
byte[] pt1 = ("static counter").getBytes();
byte[] iv = new byte[16];
SecureRandom.getInstanceStrong().nextBytes(iv);
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(128);
Key k = g.generateKey();
Cipher enc = Cipher.getInstance("AES/CBC/NoPadding", "BC");
Cipher dec = Cipher.getInstance("AES/CBC/NoPadding", "BC");
byte[] ct;
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv));
ct = enc.doFinal(pt1);
byte[] iv2 = enc.getIV();
dec.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(iv2));
byte[] pt2 = dec.doFinal(ct);
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv));
ct = enc.doFinal(pt1);
iv2 = enc.getIV();
dec.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(iv2));
pt2 = dec.doFinal(ct);
}
}
| 1,700 | 31.711538 | 101 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/randomIV/src/main/java/example/UseRandomIVsForCFB.java |
package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class UseRandomIVsForCFB {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
byte[] pt1 = ("demo text").getBytes();
byte[] iv = new byte[16];
SecureRandom.getInstanceStrong().nextBytes(iv);
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
Cipher enc = Cipher.getInstance("AES/CFB/NoPadding", "BC");
Cipher dec = Cipher.getInstance("AES/CFB/NoPadding", "BC");
byte[] ct;
for (int i = 0; i < 5; i++) {
SecureRandom.getInstanceStrong().nextBytes(iv);
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv));
ct = enc.doFinal(pt1);
dec.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(enc.getIV()));
byte[] pt2 = dec.doFinal(ct);
}
}
}
| 1,569 | 33.130435 | 101 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/randomIV/src/main/java/example/UseRandomIVsForCFB128.java |
package example;
import java.security.InvalidAlgorithmParameterException;
import java.security.InvalidKeyException;
import java.security.Key;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.SecureRandom;
import java.security.Security;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
public final class UseRandomIVsForCFB128 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
byte[] pt1 = ("demo text").getBytes();
byte[] iv = new byte[16];
SecureRandom.getInstanceStrong().nextBytes(iv);
KeyGenerator g = KeyGenerator.getInstance("AES", "BC");
g.init(256);
Key k = g.generateKey();
Cipher enc = Cipher.getInstance("AES/CFB128/NoPadding", "BC");
Cipher dec = Cipher.getInstance("AES/CFB128/NoPadding", "BC");
byte[] ct;
for (int i = 0; i < 5; i++) {
SecureRandom.getInstanceStrong().nextBytes(iv);
enc.init(Cipher.ENCRYPT_MODE, k, new IvParameterSpec(iv));
ct = enc.doFinal(pt1);
dec.init(Cipher.DECRYPT_MODE, k, new IvParameterSpec(enc.getIV()));
byte[] pt2 = dec.doFinal(ct);
}
}
}
| 1,578 | 33.326087 | 101 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/secureConfigsRSA/src/main/java/example/SecureConfig112bitsRSA_2048x256_1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig112bitsRSA_2048x256_1 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 256;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA256;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA-256", "MGF1", mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] pt1 = "demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(pt1);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] pt2 = c.doFinal(ct);
}
}
| 1,272 | 29.309524 | 106 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/secureConfigsRSA/src/main/java/example/SecureConfig112bitsRSA_2048x256_2.java | package example;
import javax.crypto.*;
import java.security.*;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig112bitsRSA_2048x256_2 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 2048;
int hsize = 256;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
Cipher c = Cipher.getInstance("RSA/None/OAEPwithSHA256andMGF1Padding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk);
byte[] pt1 = "demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(pt1);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk);
byte[] pt2 = c.doFinal(ct);
}
}
| 1,019 | 27.333333 | 101 | java |
CryptoAnalysis | CryptoAnalysis-master/CryptoAnalysisTargets/BragaCryptoBench/cryptogooduses/secureConfigsRSA/src/main/java/example/SecureConfig128bitsRSA_3072x384_1.java | package example;
import javax.crypto.*;
import java.security.*;
import java.security.spec.*;
import javax.crypto.spec.*;
import javax.crypto.spec.PSource;
import org.bouncycastle.jce.provider.*;
public final class SecureConfig128bitsRSA_3072x384_1 {
public static void main(String args[])
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, BadPaddingException,
IllegalBlockSizeException, NoSuchProviderException, InvalidAlgorithmParameterException {
Security.addProvider(new BouncyCastleProvider());
int ksize = 3072;
int hsize = 384;
int maxLenBytes = (ksize - 2 * hsize) / 8 - 2;
KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA", "BC");
kpg.initialize(ksize);
KeyPair kp = kpg.generateKeyPair();
MGF1ParameterSpec mgf1ps = MGF1ParameterSpec.SHA384;
OAEPParameterSpec OAEPps = new OAEPParameterSpec("SHA-384", "MGF1", mgf1ps, PSource.PSpecified.DEFAULT);
Cipher c = Cipher.getInstance("RSA/None/OAEPPadding", "BC");
Key pubk = kp.getPublic();
c.init(Cipher.ENCRYPT_MODE, pubk, OAEPps);
byte[] pt1 = "demo text".substring(0, maxLenBytes).getBytes();
byte[] ct = c.doFinal(pt1);
Key privk = kp.getPrivate();
c.init(Cipher.DECRYPT_MODE, privk, OAEPps);
byte[] pt2 = c.doFinal(ct);
}
}
| 1,272 | 29.309524 | 106 | java |