App ID鉴权介绍

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;

public class HmacSHA256 {

     //十六进制字符集
     private final static char[] DIGEST_ARRAYS = {
         '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
     };
     
      /**
      * 功能：Signature生成算法
      * 输入参数：
      *          1.data: HMAC-SHA256的输入数据
      *          2.key: App Key
      * 输出参数：十六进制字符串编码的HMAC-SHA256值
      */
     public static String encode(String data, String key) {
         byte[] hashByte;
         try {
             Mac sha256HMAC = Mac.getInstance("HmacSHA256");
             SecretKeySpec secretKey = new SecretKeySpec(key.getBytes("UTF-8"), "HmacSHA256");
             sha256HMAC.init(secretKey);

             hashByte = sha256HMAC.doFinal(data.getBytes("UTF-8"));
         } catch (NoSuchAlgorithmException | UnsupportedEncodingException | InvalidKeyException e) {
             return null;
         }

         return bytesToHex(hashByte);
     }

     /**
      * 功能：byte类型数组转换成十六进制字符串
      * 输入参数：
      *          1.bytes:被转换的字节数组
      * 输出参数：十六进制字符串
      */
     private static String bytesToHex(byte[] bytes) {
         StringBuffer hexStr = new StringBuffer();
         for (int i = 0; i < bytes.length; i++) {
             hexStr.append(DIGEST_ARRAYS[bytes[i] >>> 4 & 0X0F]);
             hexStr.append(DIGEST_ARRAYS[bytes[i] & 0X0F]);
         }

         return hexStr.toString();
     }
 }

#include <openssl/hmac.h>  
#include <string.h>  
#include <iostream>  
using namespace std;
 
const int HMAC_ENCODE_SUCCESS = 0;
const int HMAC_ENCODE_FAIL = -1;
const int HMAC_SHA256_STR_LEN = 65;
 
/**
* 功能: 字节流转换成十六进制字符串
* 输入参数：
*          1.input: 字节流指针
*          2.len: 字节流字节数
* 输出参数：
*          3.output: 输出缓冲区
*          6.output_length: Signature字符串长度
* 返回值：
*          0：失败
*          大于0的整数：转换后的字符串长度
*/
int Byte2HexStr(char * output, unsigned char * input, unsigned int len)
{
    if ((NULL == output) || (NULL == input))
    {
        return 0;
    }
 
    unsigned int i = 0;
    for (i = 0; i < len; i++)
    {
        sprintf_s(output + 2*i, HMAC_SHA256_STR_LEN-2*i, "%x%x", (input[i] >> 4) & 0x0F, input[i]&0x0F);
    }
 
    *(output + 2*i) = '\0';
 
    return 2*i;
}
 
 
/**
* 功能: Signature生成算法
* 输入参数：
*          1.key: App Key
*          2.key_length: App Key的字符串长度
*          3.input: HMAC-SHA256的输入数据
*          4.input_length: HMAC-SHA256的输入数据的字符串长度
* 输出参数：
*          5.output: Signature输出缓冲区
*          6.output_length: Signature字符串长度
* 返回值：
*          0：成功
*          -1：失败
*/
int HmacEncode(const char * key, unsigned int key_length,
    const char * input, unsigned int input_length,
    char output[HMAC_SHA256_STR_LEN], unsigned int &output_length) {
 
    //计算HMAC_SHA256的字节流
    const EVP_MD * engine = EVP_sha256();
 
    unsigned char * byte_output = (unsigned char*)malloc(EVP_MAX_MD_SIZE);
    if (NULL == byte_output)
    {
        output_length = 0;
        return HMAC_ENCODE_FAIL;
    }
    unsigned int  byte_output_length = 0;
 
    HMAC_CTX *ctx;
    ctx = HMAC_CTX_new();
 
    HMAC_Init(ctx, key, strlen(key), engine);
    HMAC_Update(ctx, (unsigned char*)input, strlen(input));
    HMAC_Final(ctx, byte_output, &byte_output_length);
 
    HMAC_CTX_free(ctx);
 
    //HMAC_SHA256的字节流转换成十六进制字符串
    int ret = Byte2HexStr(output, byte_output, byte_output_length);
    free(byte_output);
 
    if (0 == ret)
    {   
        output_length = 0;
        return HMAC_ENCODE_FAIL;
    }
    else
    {
        output_length = ret;
        return HMAC_ENCODE_SUCCESS;
    }
 
}