/**
* Created primary key using openssl.
*
* <p>openssl req -x509 -nodes -days 365 -newkey rsa:1024 -sha1 -subj
* '/C=GB/ST=/L=Manchester/CN=www.example.com' -keyout myrsakey.pem -out /tmp/myrsacert.pem
* openssl pkcs8 -in myrsakey.pem -topk8 -nocrypt -out myrsakey.pk8
*/
private static PrivateKey getPrivateKey() {
String str =
"MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAMPQ5BCMxlUq2TYy\n"
+ "iRIoEUsz6HGTJhHuasS2nx1Se4Co3lxwxyubVdFj8AuhHNJSmJvjlpbTsGOjLZpr\n"
+ "HyDEDdJmf1Fensh1MhUnBZ4a7uLrZrKzFHHJdamX9pxapB89vLeHlCot9hVXdrZH\n"
+ "nNtg6FdmRKH/8gbs8iDyIayFvzYDAgMBAAECgYA+c9MpTBy9cQsR9BAvkEPjvkx2\n"
+ "XL4ZnfbDgpNA4Nuu7yzsQrPjPomiXMNkkiAFHH67yVxwAlgRjyuuQlgNNTpKvyQt\n"
+ "XcHxffnU0820VmE23M+L7jg2TlB3+rUnEDmDvCoyjlwGDR6lNb7t7Fgg2iR+iaov\n"
+ "0iVzz+l9w0slRlyGsQJBAPWXW2m3NmFgqfDxtw8fsKC2y8o17/cnPjozRGtWb8LQ\n"
+ "g3VCb8kbOFHOYNGazq3M7+wD1qILF2h/HecgK9eQrZ0CQQDMHXoJMfKKbrFrTKgE\n"
+ "zyggO1gtuT5OXYeFewMEb5AbDI2FfSc2YP7SHij8iQ2HdukBrbTmi6qxh3HmIR58\n"
+ "I/AfAkEA0Y9vr0tombsUB8cZv0v5OYoBZvCTbMANtzfb4AOHpiKqqbohDOevLQ7/\n"
+ "SpvgVCmVaDz2PptcRAyEBZ5MCssneQJAB2pmvaDH7Ambfod5bztLfOhLCtY5EkXJ\n"
+ "n6rZcDbRaHorRhdG7m3VtDKOUKZ2DF7glkQGV33phKukErVPUzlHBwJAScD9TqaG\n"
+ "wJ3juUsVtujV23SnH43iMggXT7m82STpPGam1hPfmqu2Z0niePFo927ogQ7H1EMJ\n"
+ "UHgqXmuvk2X/Ww==";
try {
KeyFactory fac = KeyFactory.getInstance("RSA");
PKCS8EncodedKeySpec privKeySpec =
new PKCS8EncodedKeySpec(DatatypeConverter.parseBase64Binary(str));
return fac.generatePrivate(privKeySpec);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public SymmetricCryptor getSymmetricCryptor(
byte[] peerPublicKeyBytes, boolean useSealedObject, ClassLoader classLoader)
throws CryptoException {
if (privateKey == null) {
throw new IllegalStateException(
"KeyGenerator did not successfully generate public key"); //$NON-NLS-1$
}
try {
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(peerPublicKeyBytes);
KeyFactory keyFact = KeyFactory.getInstance(ALGORITHM);
PublicKey publicKey = keyFact.generatePublic(x509KeySpec);
KeyAgreement ka = KeyAgreement.getInstance(ALGORITHM);
ka.init(privateKey);
ka.doPhase(publicKey, true);
byte[] secret = ka.generateSecret();
MessageDigest sha = MessageDigest.getInstance(DIGEST);
byte[] hash = sha.digest(secret);
byte[] symKey = new byte[keySize / 8];
System.arraycopy(hash, 0, symKey, 0, symKey.length);
SymmetricCryptor sc = SymmetricCryptor.getSymmectricCryptor(symKey);
sc.setUseSealedObject(useSealedObject);
sc.setClassLoader(classLoader);
return sc;
} catch (NoSuchAlgorithmException e) {
throw new CryptoException(CorePlugin.Event.TEIID10003, e);
} catch (InvalidKeySpecException e) {
throw new CryptoException(CorePlugin.Event.TEIID10004, e);
} catch (InvalidKeyException e) {
throw new CryptoException(CorePlugin.Event.TEIID10005, e);
}
}
public byte[] new_decrypt_cn(E_CODE paramE_CODE, byte[] paramArrayOfByte)
throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeySpecException,
InvalidKeyException, IllegalBlockSizeException, BadPaddingException {
byte[] localObject = null;
if (paramE_CODE == E_CODE.RSA) {
if (rsa_key.length() > 2) {
Cipher localCipher;
byte[] arrayOfByte = new byte[0];
// PublicKey localPublicKey = KeyFactory.getInstance("RSA").generatePublic(new
// X509EncodedKeySpec(Base64.decodeBase64(rsa_key)));
PublicKey localPublicKey =
KeyFactory.getInstance("RSA")
.generatePublic(new X509EncodedKeySpec(Base64.decode(rsa_key, Base64.DEFAULT)));
System.out.println("key length-" + (Base64.decode(rsa_key, Base64.DEFAULT)).length);
System.out.println("data length-" + paramArrayOfByte.length);
localCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
localCipher.init(Cipher.DECRYPT_MODE, localPublicKey);
// localCipher.init(Cipher.ENCRYPT_MODE, localPublicKey);
arrayOfByte = localCipher.doFinal(paramArrayOfByte);
// int oldLength;
// for (int i = 0; i < paramArrayOfByte.length; i += 8) {
// byte[] temp = localCipher.doFinal(paramArrayOfByte, i, i + 8);
// oldLength = arrayOfByte.length;
// arrayOfByte = Arrays.copyOf(arrayOfByte, temp.length+arrayOfByte.length);
// System.arraycopy(temp, 0, arrayOfByte, oldLength, temp.length);
// }
// arrayOfByte = paramArrayOfByte;
return arrayOfByte;
}
} else if (paramE_CODE == E_CODE.RSA_EP) {
if (rsa_ep_key.length() >= 2) {
// PrivateKey localPrivateKey = KeyFactory.getInstance("RSA").generatePrivate(new
// PKCS8EncodedKeySpec(Base64.decodeBase64(rsa_ep_key)));
PrivateKey localPrivateKey =
KeyFactory.getInstance("RSA")
.generatePrivate(
new PKCS8EncodedKeySpec(Base64.decode(rsa_ep_key, Base64.DEFAULT)));
Cipher localCipher2 = Cipher.getInstance("RSA/ECB/PKCS1Padding");
localCipher2.init(2, localPrivateKey);
localObject = localCipher2.doFinal(paramArrayOfByte);
}
} else if (paramE_CODE == E_CODE.AES) {
// SecretKeySpec localSecretKeySpec = new
// SecretKeySpec(Base64.decodeBase64(aes_key.getBytes()), "AES");
// byte[] arrayOfByte1 = Base64.decodeBase64(paramArrayOfByte);
SecretKeySpec localSecretKeySpec =
new SecretKeySpec(Base64.decode(aes_key.getBytes(), Base64.DEFAULT), "AES");
byte[] arrayOfByte1 = Base64.decode(paramArrayOfByte, Base64.DEFAULT);
Cipher localCipher1 = Cipher.getInstance("AES/ECB/PKCS5Padding");
localCipher1.init(Cipher.DECRYPT_MODE, localSecretKeySpec);
byte[] arrayOfByte2 = localCipher1.doFinal(arrayOfByte1);
localObject = arrayOfByte2;
}
return localObject;
}
/**
* Converts a PEM-encoded PKCS#8 private key into an RSAPrivateKey instance useable with JCE
*
* @param privateKey private key in PKCS#8 format and PEM-encoded
* @return RSAPrivateKey instance containing the key
*/
private static RSAPrivateKey rsaPrivateKeyDecode(final String privateKey) {
try {
final KeyFactory keyFactory = KeyFactory.getInstance("RSA");
final KeySpec ks = new PKCS8EncodedKeySpec(Base64.decodePadded(privateKey));
return (RSAPrivateKey) keyFactory.generatePrivate(ks);
} catch (final Exception e) {
throw new RuntimeException("Failed to decode built-in private key", e);
}
}
/**
* ��ȡWEB������·��
*
* @return
*/
public static String getWebinfPath() {
String strWebPath = "";
String res = null;
KeyFactory oTemp = new KeyFactory();
String classname = oTemp.getClass().getName().replace('.', File.separatorChar) + ".class";
ClassLoader oClassLoader = oTemp.getClass().getClassLoader();
if (oClassLoader != null) {
java.net.URL url = oClassLoader.getResource(classname);
if (url != null) {
String filePath = url.getFile();
int fileStrPosition = filePath.indexOf("file:/");
int begin = 0;
int end = filePath.length();
if (fileStrPosition >= 0) {
begin = fileStrPosition + "file:".length();
}
// ���ж��Ƿ���δ����ļ�
end = filePath.indexOf("classes/" + classname);
if (end < 0) {
// �������webModule�����jar��
end = filePath.indexOf("lib/");
if (end < 0) {
// ����ͨĿ¼�µ�jar��
int tmpend = filePath.indexOf("!/");
if (tmpend >= 0) {
end = filePath.substring(0, tmpend).lastIndexOf("/");
}
}
}
String rf = "";
if (end < 0) {
rf = filePath.substring(begin, filePath.length());
} else {
rf = filePath.substring(begin, end);
}
res = new File(rf).getAbsolutePath().replace('\\', '/') + "/";
}
}
try {
strWebPath = java.net.URLDecoder.decode(res, "UTF-8");
} catch (UnsupportedEncodingException ex) {
}
return strWebPath;
}
private PrivateKey getPrivateKey(BigInteger privExp, BigInteger modulus)
throws InvalidKeySpecException {
RSAPrivateKeySpec privSpec = new RSAPrivateKeySpec(modulus, privExp);
KeyFactory keyFactory = null;
try {
keyFactory = KeyFactory.getInstance("RSA");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return keyFactory.generatePrivate(privSpec);
}
/**
* used to reconstitute public key sent in byte form from peer
*
* @param encodedKey
* @return PublicKey
*/
private PublicKey generatePubKey(byte[] encodedKey) {
PublicKey pubKey = null;
try {
KeyFactory KeyFac = KeyFactory.getInstance(getAlgorithm(asymAlgorithm));
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(encodedKey);
pubKey = KeyFac.generatePublic(x509KeySpec);
} catch (Exception e) {
e.printStackTrace();
}
return pubKey;
}
/**
* Complete the key agreement protocol with the peer public value <code>otherPublic</code> and
* return the calculated shared secret.
*
* @param otherPublic The peer public value.
* @return The shared secret value produced by the protocol.
*/
public byte[] getSharedSecret(BigInteger otherPublic) {
try {
KeyFactory factory = KeyFactory.getInstance("DH");
DHPublicKeySpec pub = new DHPublicKeySpec(otherPublic, P1024, G);
PublicKey key = factory.generatePublic(pub);
dh.doPhase(key, true);
return dh.generateSecret();
} catch (GeneralSecurityException e) {
throw new TorException(e);
}
}
public static VotifierKeyPair read(JsonObject source) throws Exception {
byte[] publicKeyEnc = Base64.getDecoder().decode(source.get("public_key").getAsString());
byte[] privateKeyEnc = Base64.getDecoder().decode(source.get("private_key").getAsString());
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(new X509EncodedKeySpec(publicKeyEnc));
PrivateKey privateKey = keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKeyEnc));
return new VotifierKeyPair(new KeyPair(publicKey, privateKey));
}
public static void savePublicKeyInFile(String path, PublicKey key) {
try {
KeyFactory fac = KeyFactory.getInstance("RSA");
RSAPublicKeySpec RSAspec = fac.getKeySpec(key, RSAPublicKeySpec.class);
FileOutputStream file3 = new FileOutputStream(path);
ObjectOutputStream obj_stream = new ObjectOutputStream(file3);
obj_stream.writeObject(RSAspec.getModulus());
obj_stream.writeObject(RSAspec.getPublicExponent());
} catch (Exception ex) {
System.err.println("Probeleme de sauvegarde de la cle public dans un fichier: " + ex);
}
}
public static PublicKey func_75896_a(byte p_75896_0_[]) {
try {
X509EncodedKeySpec x509encodedkeyspec = new X509EncodedKeySpec(p_75896_0_);
KeyFactory keyfactory = KeyFactory.getInstance("RSA");
return keyfactory.generatePublic(x509encodedkeyspec);
} catch (NoSuchAlgorithmException nosuchalgorithmexception) {
nosuchalgorithmexception.printStackTrace();
} catch (InvalidKeySpecException invalidkeyspecexception) {
invalidkeyspecexception.printStackTrace();
}
System.err.println("Public key reconstitute failed!");
return null;
}
/**
* Get the secret data that has been agreed on through Diffie-Hellman key agreement protocol. Note
* that in the two party protocol, if the peer keys are already known, no other data needs to be
* sent in order to agree on a secret. That is, a secured message may be sent without any
* mandatory round-trip overheads.
*
* <p>It is illegal to call this member function if the private key has not been set (or
* generated).
*
* @param peerPublicKey the peer's public key.
* @returns the secret, which is an unsigned big-endian integer the same size as the
* Diffie-Hellman modulus.
*/
SecretKey getAgreedSecret(BigInteger peerPublicValue) {
try {
KeyFactory kf = JsseJce.getKeyFactory("DiffieHellman");
DHPublicKeySpec spec = new DHPublicKeySpec(peerPublicValue, modulus, base);
PublicKey publicKey = kf.generatePublic(spec);
KeyAgreement ka = JsseJce.getKeyAgreement("DiffieHellman");
ka.init(privateKey);
ka.doPhase(publicKey, true);
return ka.generateSecret("TlsPremasterSecret");
} catch (GeneralSecurityException e) {
throw new RuntimeException("Could not generate secret", e);
}
}
static DHPublicKeySpec getDHPublicKeySpec(PublicKey key) {
if (key instanceof DHPublicKey) {
DHPublicKey dhKey = (DHPublicKey) key;
DHParameterSpec params = dhKey.getParams();
return new DHPublicKeySpec(dhKey.getY(), params.getP(), params.getG());
}
try {
KeyFactory factory = JsseJce.getKeyFactory("DH");
return (DHPublicKeySpec) factory.getKeySpec(key, DHPublicKeySpec.class);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public PublicKey LoadPublicKey(String path, String algorithm)
throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
// Read Public Key.
File filePublicKey = new File(path + "public.key");
FileInputStream fis = new FileInputStream(path + "public.key");
byte[] encodedPublicKey = new byte[(int) filePublicKey.length()];
fis.read(encodedPublicKey);
fis.close();
// Generate PublicKey.
KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
X509EncodedKeySpec publicKeySpec = new X509EncodedKeySpec(encodedPublicKey);
PublicKey publicKey = keyFactory.generatePublic(publicKeySpec);
return publicKey;
}
/**
* Convert a byte array to an EC private key by decoding the D number parameter.
*
* @param keyBytes Bytes to be converted to the EC private key.
* @return An instance of EC private key decoded from the input bytes.
* @throws InvalidKeySpecException The provided key bytes are not a valid EC private key.
*/
@Override
public PrivateKey convertBytesToPrivateKey(byte[] keyBytes) throws InvalidKeySpecException {
try {
KeyFactory kf = KeyFactory.getInstance("ECDH", getProviderName());
BigInteger keyInteger = new BigInteger(keyBytes);
ECParameterSpec ecSpec = ECNamedCurveTable.getParameterSpec("secp256r1");
ECPrivateKeySpec pubSpec = new ECPrivateKeySpec(keyInteger, ecSpec);
ECPrivateKey privateKey = (ECPrivateKey) kf.generatePrivate(pubSpec);
return privateKey;
} catch (NoSuchAlgorithmException | NoSuchProviderException ex) {
Logger.getLogger(this.getClass().getName()).log(Level.SEVERE, null, ex);
}
return null;
}
/**
* Generates a PublicKey instance from a string containing the Base64-encoded public key.
*
* @param encodedPublicKey Base64-encoded public key
* @throws IllegalArgumentException if encodedPublicKey is invalid
*/
private PublicKey generatePublicKey(String encodedPublicKey) {
try {
byte[] decodedKey = Base64.decode(encodedPublicKey);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_FACTORY_ALGORITHM);
return keyFactory.generatePublic(new X509EncodedKeySpec(decodedKey));
} catch (NoSuchAlgorithmException e) {
throw new RuntimeException(e);
} catch (InvalidKeySpecException e) {
Log.e(TAG, "Invalid key specification.");
throw new IllegalArgumentException(e);
} catch (Base64DecoderException e) {
Log.e(TAG, "Base64 decoding failed.");
throw new IllegalArgumentException(e);
}
}
@Override
public Key next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return KeyFactory.createKey(parent, kind, next++, appIdNamespace);
}
@PUT
@Consumes(MediaType.APPLICATION_XML)
public Response putTaskData(String value) {
Response res = null;
// add your code here
// first check if the Entity exists in the datastore
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
syncCache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
Key entKey = KeyFactory.createKey("TaskData", keyname);
Date date = new Date();
try {
// if it is, signal that we updated the entity
Entity ts = datastore.get(entKey);
ts.setProperty("value", value);
ts.setProperty("date", date);
datastore.put(ts);
res = Response.noContent().build();
} catch (EntityNotFoundException e) {
// if it is not, create it and
// signal that we created the entity in the datastore
Entity taskdata = new Entity("TaskData", keyname);
taskdata.setProperty("value", value);
taskdata.setProperty("date", date);
datastore.put(taskdata);
res = Response.created(uriInfo.getAbsolutePath()).build();
}
TaskData td = new TaskData(keyname, value, date);
syncCache.put(keyname, td);
return res;
}
public void setPubKey(byte[] y, byte[] p, byte[] q, byte[] g) throws Exception {
DSAPublicKeySpec dsaPubKeySpec =
new DSAPublicKeySpec(
new BigInteger(y), new BigInteger(p), new BigInteger(q), new BigInteger(g));
PublicKey pubKey = keyFactory.generatePublic(dsaPubKeySpec);
signature.initVerify(pubKey);
}
public void setPrvKey(byte[] x, byte[] p, byte[] q, byte[] g) throws Exception {
DSAPrivateKeySpec dsaPrivKeySpec =
new DSAPrivateKeySpec(
new BigInteger(x), new BigInteger(p), new BigInteger(q), new BigInteger(g));
PrivateKey prvKey = keyFactory.generatePrivate(dsaPrivKeySpec);
signature.initSign(prvKey);
}
/**
* Construct a private key from its encoding.
*
* @param encodedKey the encoding of a private key.
* @param encodedKeyAlgorithm the algorithm the wrapped key is for.
* @return a private key constructed from the encodedKey.
*/
private static final PrivateKey constructPrivateKey(byte[] encodedKey, String encodedKeyAlgorithm)
throws InvalidKeyException, NoSuchAlgorithmException {
try {
KeyFactory keyFactory = KeyFactory.getInstance(encodedKeyAlgorithm);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(encodedKey);
return keyFactory.generatePrivate(keySpec);
} catch (NoSuchAlgorithmException nsae) {
throw new NoSuchAlgorithmException(
"No installed providers "
+ "can create keys for the "
+ encodedKeyAlgorithm
+ "algorithm",
nsae);
} catch (InvalidKeySpecException ike) {
throw new InvalidKeyException("Cannot construct private key", ike);
}
}
protected Key getMetadataKeyForBlobKey(BlobKey blobKey) {
String origNamespace = NamespaceManager.get();
NamespaceManager.set("");
try {
return KeyFactory.createKey(null, BlobInfoFactory.KIND, blobKey.getKeyString());
} finally {
NamespaceManager.set(origNamespace);
}
}
private boolean checkSignature(String publicKey, String strToSign, byte[] sign) {
try {
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
byte[] encodedKey = Base64.decodeBase64(publicKey);
PublicKey pubKey = keyFactory.generatePublic(new X509EncodedKeySpec(encodedKey));
java.security.Signature signature = java.security.Signature.getInstance("MD5withRSA");
signature.initVerify(pubKey);
signature.update(strToSign.getBytes());
return signature.verify(sign);
} catch (InvalidKeySpecException
| NoSuchAlgorithmException
| SignatureException
| InvalidKeyException e) {
log.error(e.getMessage());
}
return false;
}
public static Entity GetEntity(String slideKey, String questionText, int rating) {
Entity questionEntity = new Entity("Question", KeyFactory.stringToKey(slideKey));
questionEntity.setProperty("Text", questionText);
questionEntity.setProperty("Rating", rating);
questionEntity.setProperty("DatePosted", new Date());
return questionEntity;
}
public static Question GetQuestion(Entity entity) {
Question q = new Question();
q.key = KeyFactory.keyToString(entity.getKey());
q.questionText = (String) entity.getProperty("Text");
q.rating = (Long) entity.getProperty("Rating");
q.datePosted = (Date) entity.getProperty("DatePosted");
return q;
}
/**
* Converts byte array to an EC public key, by decoding the Q point parameter.
*
* @param keyBytes Bytes to be converted to EC public key.
* @return An instance of the EC public key on success, or null on failure.
* @throws InvalidKeySpecException When provided bytes are not a correct key representation.
*/
@Override
public PublicKey convertBytesToPublicKey(byte[] keyBytes) throws InvalidKeySpecException {
try {
KeyFactory kf = KeyFactory.getInstance("ECDH", getProviderName());
ECNamedCurveParameterSpec ecSpec = ECNamedCurveTable.getParameterSpec("secp256r1");
if (ecSpec == null) { // can happen with incorrectly initialized crypto provider
return null;
}
ECPoint point = ecSpec.getCurve().decodePoint(keyBytes);
ECPublicKeySpec pubSpec = new ECPublicKeySpec(point, ecSpec);
ECPublicKey publicKey = (ECPublicKey) kf.generatePublic(pubSpec);
return publicKey;
} catch (NoSuchAlgorithmException | NoSuchProviderException ex) {
Logger.getLogger(this.getClass().getName()).log(Level.SEVERE, null, ex);
}
return null;
}
public byte[] getK() throws Exception {
if (K == null) {
KeyFactory myKeyFac = KeyFactory.getInstance("DH");
DHPublicKeySpec keySpec = new DHPublicKeySpec(f, p, g);
PublicKey yourPubKey = myKeyFac.generatePublic(keySpec);
myKeyAgree.doPhase(yourPubKey, true);
byte[] mySharedSecret = myKeyAgree.generateSecret();
K = new BigInteger(mySharedSecret);
K_array = K.toByteArray();
// System.err.println("K.signum(): "+K.signum()+
// " "+Integer.toHexString(mySharedSecret[0]&0xff)+
// " "+Integer.toHexString(K_array[0]&0xff));
K_array = mySharedSecret;
}
return K_array;
}
static {
try {
FileInputStream keyfis = new FileInputStream("src/com/ingenium/ash/publicIngenium");
byte[] encKey = new byte[keyfis.available()];
keyfis.read(encKey);
keyfis.close();
X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(encKey);
KeyFactory keyFactory = KeyFactory.getInstance("DSA", "SUN");
pubKey = keyFactory.generatePublic(pubKeySpec);
} catch (InvalidKeySpecException ex) {
Logger.getLogger(SignatureVerifier.class.getName()).log(Level.SEVERE, null, ex);
} catch (NoSuchAlgorithmException ex) {
Logger.getLogger(SignatureVerifier.class.getName()).log(Level.SEVERE, null, ex);
} catch (NoSuchProviderException ex) {
Logger.getLogger(SignatureVerifier.class.getName()).log(Level.SEVERE, null, ex);
} catch (FileNotFoundException ex) {
Logger.getLogger(SignatureVerifier.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(SignatureVerifier.class.getName()).log(Level.SEVERE, null, ex);
}
}
public String toString() {
StringBuilder b = new StringBuilder();
Key k = KeyFactory.stringToKey(key);
b.append("Question (").append(k.getId()).append(") : ").append(" Text=").append(questionText);
b.append(" Date Posted=").append(datePosted);
b.append(" ParentInfo = ").append(k.getParent().toString());
b.append("\n");
for (Comment c : comments) {
b.append("\t\t").append(c.toString()).append("\n");
}
return b.toString();
}
KeyRange(Key parent, String kind, long start, long end, AppIdNamespace appIdNamespace) {
if (parent != null && !parent.isComplete()) {
throw new IllegalArgumentException("Invalid parent: not a complete key");
}
if (kind == null || kind.equals("")) {
throw new IllegalArgumentException("Invalid kind: cannot be null or empty");
}
if (start < 1) {
throw new IllegalArgumentException("Illegal start " + start + ": less than 1");
}
if (end < start) {
throw new IllegalArgumentException("Illegal end " + end + ": less than start " + start);
}
this.parent = parent;
this.kind = kind;
this.appIdNamespace = appIdNamespace;
this.start = KeyFactory.createKey(parent, kind, start, appIdNamespace);
this.end = KeyFactory.createKey(parent, kind, end, appIdNamespace);
}
