public static String getCryptUrl(String paramString) {
   StringBuffer localStringBuffer = new StringBuffer(paramString);
   if (paramString.indexOf("?") == -1) {
     localStringBuffer.append("?");
   } else {
     localStringBuffer.append("&");
   }
   localStringBuffer.append("cyt=1");
   return localStringBuffer.toString();
 }
Beispiel #2
0
  /** Transform the specified byte into a Hex String form. */
  public static final String bytesToHexStr(byte[] bcd) {
    StringBuffer s = new StringBuffer(bcd.length * 2);

    for (int i = 0; i < bcd.length; i++) {
      s.append(bcdLookup[(bcd[i] >>> 4) & 0x0f]);
      s.append(bcdLookup[bcd[i] & 0x0f]);
    }

    return s.toString();
  }
 /* Cert RQ info header */
 private String buildRequestInfoHeader(String subject) {
   StringBuffer buff =
       new StringBuffer(
           "This is a Certificate Request file:\nIt should be mailed to to a CA for signature");
   buff.append("\n===============================================================");
   buff.append("\nCertificate Subject:\n\t");
   buff.append(subject);
   buff.append("\n\n");
   return buff.toString();
 }
Beispiel #4
0
 /** Return string representation of this VMID. */
 public String toString() {
   StringBuffer result = new StringBuffer();
   if (addr != null)
     for (int i = 0; i < addr.length; ++i) {
       int x = (int) (addr[i] & 0xFF);
       result.append((x < 0x10 ? "0" : "") + Integer.toString(x, 16));
     }
   result.append(':');
   result.append(uid.toString());
   return result.toString();
 }
  public ManifestDigester(byte bytes[]) {
    rawBytes = bytes;
    entries = new HashMap();

    // first skip the main attributes
    Position pos = new Position();

    if (!findSection(0, pos)) return; // exception?

    int start = pos.startOfNext;

    while (findSection(start, pos)) {
      int len = pos.endOfFirstLine - start + 1;
      int sectionLen = pos.endOfSection - start + 1;
      int sectionLenWithBlank = pos.startOfNext - start;

      if (len > 6) {
        if (isNameAttr(bytes, start)) {
          StringBuffer nameBuf = new StringBuffer();
          nameBuf.append(new String(bytes, start + 6, len - 6));

          int i = start + len;
          if ((i - start) < sectionLen) {
            if (bytes[i] == '\r') {
              i += 2;
            } else {
              i += 1;
            }
          }

          while ((i - start) < sectionLen) {
            if (bytes[i++] == ' ') {
              // name is wrapped
              int wrapStart = i;
              while (((i - start) < sectionLen) && (bytes[i++] != '\n')) ;
              if (bytes[i - 1] != '\n') return; // exception?
              int wrapLen;
              if (bytes[i - 2] == '\r') wrapLen = i - wrapStart - 2;
              else wrapLen = i - wrapStart - 1;
              nameBuf.append(new String(bytes, wrapStart, wrapLen));
            } else {
              break;
            }
          }

          String name = nameBuf.toString();
          entries.put(name, new Entry(start, sectionLen, sectionLenWithBlank, rawBytes));
        }
      }
      start = pos.startOfNext;
    }
  }
Beispiel #6
0
 /**
  * Converts the given byte data into Hex string.
  *
  * @param data the byte array to convert
  * @return the Hex string representation of the given byte array
  */
 private static String convertToHex(byte[] data) {
   StringBuffer buf = new StringBuffer();
   for (int i = 0; i < data.length; i++) {
     int halfbyte = (data[i] >>> 4) & 0x0F;
     int two_halfs = 0;
     do {
       if ((0 <= halfbyte) && (halfbyte <= 9)) buf.append((char) ('0' + halfbyte));
       else buf.append((char) ('a' + (halfbyte - 10)));
       halfbyte = data[i] & 0x0F;
     } while (two_halfs++ < 1);
   }
   return buf.toString();
 }
Beispiel #7
0
 public static String getJavaStringLiteral(String text) {
   StringBuffer buf = new StringBuffer();
   buf.append('"');
   int len = text.length();
   for (int i = 0; i < len; i++) {
     char ch = text.charAt(i);
     switch (ch) {
       case '\\':
         buf.append("\\\\");
         break;
       case '\n':
         buf.append("\\n");
         break;
       case '\r':
         buf.append("\\r");
         break;
       case '\t':
         buf.append("\\t");
         break;
       case '"':
         buf.append("\\\"");
         break;
       default:
         buf.append(ch);
         break;
     }
   }
   buf.append('"');
   return buf.toString();
 }
Beispiel #8
0
 static int appendMethodSignature(Class[] argTypes, Class returnType, StringBuffer sb) {
   sb.append('(');
   int firstLocal = 1 + argTypes.length; // includes this.
   for (int i = 0; i < argTypes.length; i++) {
     Class type = argTypes[i];
     appendTypeString(sb, type);
     if (type == Long.TYPE || type == Double.TYPE) {
       // adjust for duble slot
       ++firstLocal;
     }
   }
   sb.append(')');
   appendTypeString(sb, returnType);
   return firstLocal;
 }
 public static String toString(byte[] b) {
   if (b == null) {
     return "(null)";
   }
   StringBuffer sb = new StringBuffer(b.length * 3);
   for (int i = 0; i < b.length; i++) {
     int k = b[i] & 0xff;
     if (i != 0) {
       sb.append(':');
     }
     sb.append(hexDigits[k >>> 4]);
     sb.append(hexDigits[k & 0xf]);
   }
   return sb.toString();
 }
Beispiel #10
0
 public static String getJavaIdentifier(String candidateID) {
   int len = candidateID.length();
   StringBuffer buf = new StringBuffer();
   for (int i = 0; i < len; i++) {
     char ch = candidateID.charAt(i);
     boolean good =
         i == 0 ? Character.isJavaIdentifierStart(ch) : Character.isJavaIdentifierPart(ch);
     if (good) {
       buf.append(ch);
     } else {
       buf.append('_');
     }
   }
   return buf.toString();
 }
Beispiel #11
0
 /*
  * Utility method that converts a <code>URL[]</code> into a corresponding,
  * space-separated string with the same array elements. Note that if the
  * array has zero elements, the return value is null, not the empty string.
  */
 private static String urlsToPath(URL[] urls) {
   // TODO - check if spaces in file paths are properly escaped (i.e.%
   // chars)
   if (urls.length == 0) {
     return null;
   } else if (urls.length == 1) {
     return urls[0].toExternalForm();
   } else {
     StringBuffer path = new StringBuffer(urls[0].toExternalForm());
     for (int i = 1; i < urls.length; i++) {
       path.append(' ');
       path.append(urls[i].toExternalForm());
     }
     return path.toString();
   }
 }
 public static String hex(byte[] array) {
   StringBuffer sb = new StringBuffer();
   for (int i = 0; i < array.length; ++i) {
     sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1, 3));
   }
   return sb.toString();
 }
Beispiel #13
0
 private static String convertToHex(byte[] arrayBytes) {
   StringBuffer stringBuffer = new StringBuffer();
   for (int i = 0; i < arrayBytes.length; i++) {
     stringBuffer.append(Integer.toString((arrayBytes[i] & 0xff) + 0x100, 16).substring(1));
   }
   return stringBuffer.toString();
 }
Beispiel #14
0
  String[] getMedkit(
      String[] availableResources,
      String[] requiredResources,
      String[] missions,
      double P,
      double C) {
    try {
      Runtime rt = Runtime.getRuntime();
      Process proc = rt.exec(exec);
      OutputStream os = proc.getOutputStream();
      InputStream is = proc.getInputStream();
      new ErrorReader(proc.getErrorStream()).start();

      StringBuffer sb = new StringBuffer();
      append(sb, availableResources);
      append(sb, requiredResources);
      append(sb, missions);
      sb.append(P).append('\n');
      sb.append(C).append('\n');
      os.write(sb.toString().getBytes());

      BufferedReader br = new BufferedReader(new InputStreamReader(is));
      int N = Integer.parseInt(br.readLine().trim());
      String[] ret = new String[N];
      for (int i = 0; i < N; i++) ret[i] = br.readLine().trim();
      return ret;

    } catch (Exception e) {
      System.err.println("An error occurred while executing your program");
      e.printStackTrace();
      return null;
    }
  }
Beispiel #15
0
 public static String[] split(String phrase) {
   int length = phrase.length();
   ArrayList wordList = new ArrayList();
   StringBuffer word = null;
   for (int i = 0; i < length; i++) {
     char ch = phrase.charAt(i);
     switch (ch) {
       case ' ':
       case '\t':
       case '\r':
       case '\n':
         if (word != null) {
           wordList.add(word.toString());
           word = null;
         }
         break;
       default:
         if (word == null) {
           word = new StringBuffer();
         }
         word.append(ch);
     }
   }
   if (word != null) {
     wordList.add(word.toString());
   }
   return (String[]) wordList.toArray(EMPTY_ARRAY);
 }
Beispiel #16
0
 /**
  * @param s
  * @return
  */
 public static String mask(final String s) {
   final StringBuffer buffer = new StringBuffer(25);
   final int count = (s != null ? s.length() : 0);
   for (int n = 0; n < count; n++) {
     buffer.append('*');
   }
   return buffer.toString();
 }
Beispiel #17
0
 /**
  * 将byte数组转换为表示16进制值的字符串, 如:byte[]{8,18}转换为:0813, 和public static byte[] hexStr2ByteArr(String
  * strIn) 互为可逆的转换过程
  *
  * @param arrB 需要转换的byte数组
  * @return 转换后的字符串
  * @throws Exception 本方法不处理任何异常,所有异常全部抛出
  */
 public static String byteArr2HexStr(byte[] arrB) {
   int iLen = arrB.length;
   // 每个byte用两个字符才能表示,所以字符串的长度是数组长度的两倍
   StringBuffer sb = new StringBuffer(iLen * 2);
   for (int i = 0; i < iLen; i++) {
     int intTmp = arrB[i];
     // 把负数转换为正数
     while (intTmp < 0) {
       intTmp = intTmp + 256;
     }
     // 小于0F的数需要在前面补0
     if (intTmp < 16) {
       sb.append("0");
     }
     sb.append(Integer.toString(intTmp, 16));
   }
   return sb.toString();
 }
Beispiel #18
0
  public String getClassPath() {
    StringBuffer cpath = new StringBuffer();
    String sep = System.getProperty("path.separator");

    for (int i = 0; i < jars.size(); i++) {
      cpath.append((String) jars.elementAt(i) + sep);
    }

    return cpath.toString();
  }
Beispiel #19
0
 public String toString() {
   StringBuffer sb = new StringBuffer();
   sb.append(getClass().getName());
   sb.append('@');
   sb.append(Integer.toHexString(System.identityHashCode(this)));
   sb.append(" (context=");
   sb.append(_context);
   sb.append(", static_permitions=");
   sb.append(_statisPermissions);
   sb.append(')');
   return sb.toString();
 }
  /** Write certficate bytes into a PEM encoded string */
  public static String writePEM(byte[] bytes, String hdr, String ftr) throws IOException {
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    Base64OutputStream b64os = new Base64OutputStream(bos);
    b64os.write(bytes);
    b64os.flush();
    b64os.close();

    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    InputStreamReader irr = new InputStreamReader(bis);
    BufferedReader r = new BufferedReader(irr);

    StringBuffer buff = new StringBuffer();
    String line;
    buff.append(hdr);

    while ((line = r.readLine()) != null) {
      buff.append(line + "\n");
    }
    buff.append(ftr);
    return buff.toString();
  }
  /**
   * Computing the hash for a method is useful so as to create an alternate key from the method name
   * + signature.
   *
   * @param qualifiedMethodName
   * @param methodSignature
   * @return
   */
  public static String computeHash(String qualifiedMethodName, String methodSignature) {
    String fullMethodName = qualifiedMethodName + methodSignature;

    byte[] bytes = fullMethodName.getBytes();
    md5.reset();
    md5.update(bytes);

    byte[] messageBytes = md5.digest();

    StringBuffer message = new StringBuffer();
    for (byte aByte : messageBytes) {
      String expanded = Integer.toHexString(0xFF & aByte);
      if (expanded.length() == 1) {
        // normalize length of all strings
        message.append("0");
      }

      message.append(expanded);
    }

    return message.toString();
  }
  public static String Go(String rsa_len) throws NoSuchAlgorithmException {

    KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
    keyGen.initialize(Integer.valueOf(rsa_len));
    byte[] publicKey = keyGen.genKeyPair().getPublic().getEncoded();
    StringBuffer retString = new StringBuffer();

    for (int i = 0; i < publicKey.length; ++i) {
      retString.append(Integer.toHexString(0x0100 + (publicKey[i] & 0x00FF)).substring(1));
    }

    return retString.toString();
  }
Beispiel #23
0
 private static StringBuffer appendTypeString(StringBuffer sb, Class type) {
   while (type.isArray()) {
     sb.append('[');
     type = type.getComponentType();
   }
   if (type.isPrimitive()) {
     char typeLetter;
     if (type == Boolean.TYPE) {
       typeLetter = 'Z';
     } else if (type == Long.TYPE) {
       typeLetter = 'J';
     } else {
       String typeName = type.getName();
       typeLetter = Character.toUpperCase(typeName.charAt(0));
     }
     sb.append(typeLetter);
   } else {
     sb.append('L');
     sb.append(type.getName().replace('.', '/'));
     sb.append(';');
   }
   return sb;
 }
Beispiel #24
0
  public static String md5(String unhashed) {
    String hashed = "";
    byte[] defaultBytes = unhashed.getBytes();
    try {
      MessageDigest algorithm = MessageDigest.getInstance("MD5");
      algorithm.reset();
      algorithm.update(defaultBytes);
      byte messageDigest[] = algorithm.digest();

      StringBuffer hexString = new StringBuffer();
      for (int i = 0; i < messageDigest.length; i++) {
        String hex = Integer.toHexString(0xFF & messageDigest[i]);
        if (hex.length() == 1) {
          hexString.append('0');
        }
        hexString.append(hex);
      }
      hashed = hexString.toString(); // messageDigest.toString();
    } catch (NoSuchAlgorithmException nsae) {

    }
    return hashed;
  }
  public static void main(String[] args) throws Exception {
    //
    // verifica args e recebe o texto plano
    if (args.length != 1) {
      System.err.println("Usage: java DigitalSignatureExample text");
      System.exit(1);
    }
    byte[] plainText = args[0].getBytes("UTF8");
    //
    // gera o par de chaves RSA
    System.out.println("\nStart generating RSA key");
    KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
    keyGen.initialize(1024);
    KeyPair key = keyGen.generateKeyPair();
    System.out.println("Finish generating RSA key");
    //
    // define um objeto signature para utilizar MD5 e RSA
    // e assina o texto plano com a chave privada,
    // o provider utilizado tambem eh impresso
    Signature sig = Signature.getInstance("MD5WithRSA");
    sig.initSign(key.getPrivate());
    sig.update(plainText);
    byte[] signature = sig.sign();
    System.out.println(sig.getProvider().getInfo());
    System.out.println("\nSignature:");

    // converte o signature para hexadecimal
    StringBuffer buf = new StringBuffer();
    for (int i = 0; i < signature.length; i++) {
      String hex = Integer.toHexString(0x0100 + (signature[i] & 0x00FF)).substring(1);
      buf.append((hex.length() < 2 ? "0" : "") + hex);
    }

    // imprime o signature em hexadecimal
    System.out.println(buf.toString());

    //
    // verifica a assinatura com a chave publica
    System.out.println("\nStart signature verification");
    sig.initVerify(key.getPublic());
    sig.update(plainText);
    try {
      if (sig.verify(signature)) {
        System.out.println("Signature verified");
      } else System.out.println("Signature failed");
    } catch (SignatureException se) {
      System.out.println("Singature failed");
    }
  }
Beispiel #26
0
 // Other Functions
 public static String encrypt(String pass) { // Encrypts password using MD5
   try {
     MessageDigest md = MessageDigest.getInstance("MD5");
     byte[] passBytes = pass.getBytes();
     md.reset();
     byte[] digested = md.digest(passBytes);
     StringBuffer sb = new StringBuffer();
     for (int i = 0; i < digested.length; i++) {
       sb.append(Integer.toHexString(0xff & digested[i]));
     }
     return sb.toString();
   } catch (NoSuchAlgorithmException e) {
     e.printStackTrace();
   }
   return null;
 }
  /*
   * Initializes the signerInfo and the VerifierInfo from the Certificate Pair
   */
  private void initializeCertificates() {
    X509Certificate certRoot = null;
    X509Certificate certIssuer = null;
    CertificatePair trustedCertificate;
    if (getFoundCertificate() == null) {
      CertificatePair[] certs = getRootCertificates();
      if (certs.length == 0) return;
      trustedCertificate = certs[0];
    } else {
      trustedCertificate = getFoundCertificate();
    }
    certRoot = (X509Certificate) trustedCertificate.getRoot();
    certIssuer = (X509Certificate) trustedCertificate.getIssuer();

    StringBuffer strb = new StringBuffer();
    strb.append(issuerString(certIssuer.getSubjectDN()));
    strb.append("\r\n"); // $NON-NLS-1$
    strb.append(
        NLS.bind(
            Messages.JarVerificationResult_ValidBetween,
            (new String[] {
              dateString(certIssuer.getNotBefore()), dateString(certIssuer.getNotAfter())
            })));
    strb.append(checkValidity(certIssuer));
    signerInfo = strb.toString();
    if (certIssuer != null && !certIssuer.equals(certRoot)) {
      strb = new StringBuffer();
      strb.append(issuerString(certIssuer.getIssuerDN()));
      strb.append("\r\n"); // $NON-NLS-1$
      strb.append(
          NLS.bind(
              Messages.JarVerificationResult_ValidBetween,
              (new String[] {
                dateString(certRoot.getNotBefore()), dateString(certRoot.getNotAfter())
              })));
      strb.append(checkValidity(certRoot));
      verifierInfo = strb.toString();
    }
  }
  /**
   * readPEM: Read a PEM encoded base64 stream and decode it
   *
   * @param is Base64 PEM encoded stream
   * @param hdr Header delimeter (e.g. ----------CERTIFICATE---------)
   * @param ftr Footer delimeter (e.g. ----------END CERTIFICATE---------)
   * @return decoded DER bytes
   * @throws IOException if a read error occurs
   */
  public static byte[] readPEM(InputStream is, String hdr, String ftr) throws IOException {
    logger.debug("Reading PEM hdr:" + hdr + " ftr:" + ftr);
    is.reset();
    InputStreamReader irr = new InputStreamReader(is);
    BufferedReader r = new BufferedReader(irr);

    StringBuffer buff = new StringBuffer();
    String line;
    boolean read = false;

    while ((line = r.readLine()) != null) {
      if (line.equals(hdr)) {
        read = true;
        continue;
      }
      if (line.equals(ftr)) read = false;
      if (read) buff.append(line);
    }
    return Base64.decode(buff.toString().getBytes());
  }
Beispiel #29
0
 // encode password using md5
 private String encodePassword(String pass) {
   byte[] bytesOfMessage;
   String unencodedpass = md5salt + pass;
   String encodedpass = "";
   try {
     bytesOfMessage = unencodedpass.getBytes("UTF-8");
     MessageDigest md = MessageDigest.getInstance("MD5");
     byte[] digest = md.digest(bytesOfMessage);
     StringBuffer sb = new StringBuffer();
     for (int i = 0; i < digest.length; ++i) {
       sb.append(Integer.toHexString((digest[i] & 0xFF) | 0x100).substring(1, 3));
     }
     encodedpass = sb.toString();
   } catch (UnsupportedEncodingException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   } catch (NoSuchAlgorithmException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
   }
   return encodedpass;
 }
  /** Returns the URL for the request */
  public StringBuffer getRequestURL() {
    StringBuffer sb = new StringBuffer();

    sb.append(getScheme());
    sb.append("://");

    sb.append(getServerName());
    int port = getServerPort();

    if (port > 0 && port != 80 && port != 443) {
      sb.append(":");
      sb.append(port);
    }

    sb.append(getRequestURI());

    return sb;
  }