pc id

open-license-manager

2014-05-26 b5001a9a6e6d0f63f2f2d26a2f710519a6fcc6a0

pc id

 src/library/LicenseReader.cpp

@@ -64,6 +64,14 @@
            er.addEvent(PRODUCT_EXPIRED, SEVERITY_ERROR);
        }
    }
    if (has_client_sig) {
        UserPcIdentifier str_code;
        strncpy(str_code, client_signature.c_str(), sizeof(str_code));
        EVENT_TYPE event = validate_user_pc_identifier(str_code);
        if (event != OK) {
            er.addEvent(event, SEVERITY_ERROR);
        }
    }
    return er;
}

@@ -123,7 +131,7 @@
         *  sw_version_to = (optional int)
         *  from_date = YYYY-MM-DD (optional)
         *  to_date  = YYYY-MM-DD (optional)
         *  client_signature = XXXXXXXX (optional string 16)
         *  client_signature = XXXX-XXXX-XXXX-XXXX (optional string 16)
         *  license_signature = XXXXXXXXXX (mandatory, 1024)
         *  application_data = xxxxxxxxx (optional string 16)
         */
@@ -138,8 +146,19 @@
            string to_date = trim_copy(
                    ini.GetValue(productNamePtr, "to_date",
                            FullLicenseInfo::UNUSED_TIME));
            string client_signature = trim_copy(
                    ini.GetValue(productNamePtr, "client_signature", ""));
            client_signature.erase(
                    std::remove(client_signature.begin(),
                            client_signature.end(), "-"),
                    client_signature.end());
            int from_sw_version = ini.GetLongValue(productNamePtr,
                    "from_sw_version", FullLicenseInfo::UNUSED_SOFTWARE_VERSION);
            int to_sw_version = ini.GetLongValue(productNamePtr,
                    "to_sw_version", FullLicenseInfo::UNUSED_SOFTWARE_VERSION);
            FullLicenseInfo licInfo(*it, product, license_signature,
                    (int) license_version, from_date, to_date);
                    (int) license_version, from_date, to_date,
                    client_signature,from_sw_version,to_sw_version);
            licenseInfoOut.push_back(licInfo);
            atLeastOneLicenseComplete = true;
        } else {

 src/library/api/datatypes.h

@@ -93,7 +93,7 @@
 * in most cases.
 */
typedef enum {
    DEFAULT, ETHERNET, IP_ADDRESS, DISK_NUM, DISK_LABEL
    DEFAULT, ETHERNET, IP_ADDRESS, DISK_NUM, DISK_LABEL, STRATEGY_UNKNOWN
} IDENTIFICATION_STRATEGY;

#ifdef __cplusplus

 src/library/base/base64.h

New file
@@ -0,0 +1,170 @@
/*

 https://github.com/superwills/NibbleAndAHalf
 base64.h -- Fast base64 encoding and decoding.
 version 1.0.0, April 17, 2013 143a

 Copyright (C) 2013 William Sherif

 This software is provided 'as-is', without any express or implied
 warranty.  In no event will the authors be held liable for any damages
 arising from the use of this software.

 Permission is granted to anyone to use this software for any purpose,
 including commercial applications, and to alter it and redistribute it
 freely, subject to the following restrictions:

 1. The origin of this software must not be misrepresented; you must not
 claim that you wrote the original software. If you use this software
 in a product, an acknowledgment in the product documentation would be
 appreciated but is not required.
 2. Altered source versions must be plainly marked as such, and must not be
 misrepresented as being the original software.
 3. This notice may not be removed or altered from any source distribution.

 William Sherif
 will.sherif@gmail.com

 YWxsIHlvdXIgYmFzZSBhcmUgYmVsb25nIHRvIHVz

 */
#ifndef BASE64_H
#define BASE64_H

#include <stdio.h>
#include <stdlib.h>

const static char* b64 =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

// maps A=>0,B=>1..
const static unsigned char unb64[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //10
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //20
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //30
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //40
        0, 0, 0, 62, 0, 0, 0, 63, 52, 53, //50
        54, 55, 56, 57, 58, 59, 60, 61, 0, 0, //60
        0, 0, 0, 0, 0, 0, 1, 2, 3, 4, //70
        5, 6, 7, 8, 9, 10, 11, 12, 13, 14, //80
        15, 16, 17, 18, 19, 20, 21, 22, 23, 24, //90
        25, 0, 0, 0, 0, 0, 0, 26, 27, 28, //100
        29, 30, 31, 32, 33, 34, 35, 36, 37, 38, //110
        39, 40, 41, 42, 43, 44, 45, 46, 47, 48, //120
        49, 50, 51, 0, 0, 0, 0, 0, 0, 0, //130
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //140
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //150
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //160
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //170
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //180
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //190
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //200
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //210
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //220
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //230
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //240
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, //250
        0, 0, 0, 0, 0, 0, }; // This array has 255 elements

// Converts binary data of length=len to base64 characters.
// Length of the resultant string is stored in flen
// (you must pass pointer flen).
char* base64(const void* binaryData, int len, int *flen) {
    const unsigned char* bin = (const unsigned char*) binaryData;
    char* res;

    int rc = 0; // result counter
    int byteNo; // I need this after the loop

    int modulusLen = len % 3;
    int pad = ((modulusLen & 1) << 1) + ((modulusLen & 2) >> 1); // 2 gives 1 and 1 gives 2, but 0 gives 0.

    *flen = 4 * (len + pad) / 3;
    res = (char*) malloc(*flen + 1); // and one for the null
    if (!res) {
        puts("ERROR: base64 could not allocate enough memory.");
        puts("I must stop because I could not get enough");
        return 0;
    }

    for (byteNo = 0; byteNo <= len - 3; byteNo += 3) {
        unsigned char BYTE0 = bin[byteNo];
        unsigned char BYTE1 = bin[byteNo + 1];
        unsigned char BYTE2 = bin[byteNo + 2];
        res[rc++] = b64[BYTE0 >> 2];
        res[rc++] = b64[((0x3 & BYTE0) << 4) + (BYTE1 >> 4)];
        res[rc++] = b64[((0x0f & BYTE1) << 2) + (BYTE2 >> 6)];
        res[rc++] = b64[0x3f & BYTE2];
    }

    if (pad == 2) {
        res[rc++] = b64[bin[byteNo] >> 2];
        res[rc++] = b64[(0x3 & bin[byteNo]) << 4];
        res[rc++] = '=';
        res[rc++] = '=';
    } else if (pad == 1) {
        res[rc++] = b64[bin[byteNo] >> 2];
        res[rc++] = b64[((0x3 & bin[byteNo]) << 4) + (bin[byteNo + 1] >> 4)];
        res[rc++] = b64[(0x0f & bin[byteNo + 1]) << 2];
        res[rc++] = '=';
    }

    res[rc] = 0; // NULL TERMINATOR! ;)
    return res;
}

unsigned char* unbase64(const char* ascii, int len, int *flen) {
    const unsigned char *safeAsciiPtr = (const unsigned char*) ascii;
    unsigned char *bin;
    int cb = 0;
    int charNo;
    int pad = 0;

    if (len < 2) { // 2 accesses below would be OOB.
        // catch empty string, return NULL as result.
        puts(
                "ERROR: You passed an invalid base64 string (too short). You get NULL back.");
        *flen = 0;
        return 0;
    }
    if (safeAsciiPtr[len - 1] == '=')
        ++pad;
    if (safeAsciiPtr[len - 2] == '=')
        ++pad;

    *flen = 3 * len / 4 - pad;
    bin = (unsigned char*) malloc(*flen);
    if (!bin) {
        puts("ERROR: unbase64 could not allocate enough memory.");
        puts("I must stop because I could not get enough");
        return 0;
    }

    for (charNo = 0; charNo <= len - 4 - pad; charNo += 4) {
        int A = unb64[safeAsciiPtr[charNo]];
        int B = unb64[safeAsciiPtr[charNo + 1]];
        int C = unb64[safeAsciiPtr[charNo + 2]];
        int D = unb64[safeAsciiPtr[charNo + 3]];

        bin[cb++] = (A << 2) | (B >> 4);
        bin[cb++] = (B << 4) | (C >> 2);
        bin[cb++] = (C << 6) | (D);
    }

    if (pad == 1) {
        int A = unb64[safeAsciiPtr[charNo]];
        int B = unb64[safeAsciiPtr[charNo + 1]];
        int C = unb64[safeAsciiPtr[charNo + 2]];

        bin[cb++] = (A << 2) | (B >> 4);
        bin[cb++] = (B << 4) | (C >> 2);
    } else if (pad == 2) {
        int A = unb64[safeAsciiPtr[charNo]];
        int B = unb64[safeAsciiPtr[charNo + 1]];

        bin[cb++] = (A << 2) | (B >> 4);
    }

    return bin;
}

#endif

 src/library/pc-identifiers.c

@@ -9,6 +9,7 @@
#include "pc-identifiers.h"
#include <stdlib.h>
#include <stdbool.h>
#include "base/base64.h"

static FUNCTION_RETURN generate_default_pc_id(PcIdentifier * identifiers,
        unsigned int * num_identifiers) {
@@ -43,8 +44,9 @@
    for (i = 0; i < disk_num; i++) {
        for (j = 0; j < adapter_num; i++) {
            for (k = 0; k < 6; k++)
                identifiers[i * adapter_num + j][k] = diskInfos[i].disk_sn[k
                        + 2] ^ adapterInfos[j].mac_address[k + 2];
                identifiers[i * adapter_num + j][k] =
                        diskInfos[i].disk_sn[k + 2]
                                ^ adapterInfos[j].mac_address[k + 2];
        }
    }

@@ -147,7 +149,7 @@
        result = generate_default_pc_id(identifiers, array_size);
        break;
    case ETHERNET:
        result = generate_ethernet_pc_id(identifiers, array_size, false);
        result = generate_ethernet_pc_id(identifiers, array_size, true);
        break;
    case IP_ADDRESS:
        result = generate_ethernet_pc_id(identifiers, array_size, false);
@@ -156,7 +158,7 @@
        result = generate_disk_pc_id(identifiers, array_size, false);
        break;
    case DISK_LABEL:
        result = generate_disk_pc_id(identifiers, array_size, false);
        result = generate_disk_pc_id(identifiers, array_size, true);
        break;
    default:
        return ERROR;
@@ -188,7 +190,55 @@
 * @param str_code: the code in the string format XXXX-XXXX-XXXX-XXXX
 * @return
 */
int decode_pc_id(PcIdentifier* identifier1_out, PcIdentifier* identifier2_out,
        UserPcIdentifier str_code) {
static FUNCTION_RETURN decode_pc_id(PcIdentifier* identifier1_out,
        PcIdentifier* identifier2_out, UserPcIdentifier str_code) {

}

static IDENTIFICATION_STRATEGY strategy_from_pc_id(PcIdentifier identifier) {
    return (IDENTIFICATION_STRATEGY) identifier[0] >> 5;
}

EVENT_TYPE validate_user_pc_identifier(UserPcIdentifier str_code) {
    PcIdentifier user_identifiers[2];
    FUNCTION_RETURN result;
    IDENTIFICATION_STRATEGY previous_strategy_id, current_strategy_id;
    PcIdentifier* calculated_identifiers;
    size_t calc_identifiers_size;
    int i, j;
    bool found;

    result = decode_pc_id(&user_identifiers[0], &user_identifiers[1], str_code);
    if (result != OK) {
        return result;
    }
    previous_strategy_id = STRATEGY_UNKNOWN;
    found = false;
    for (i = 0; i < 2; i++) {
        current_strategy_id = strategy_from_pc_id(user_identifiers[i]);
        if (current_strategy_id == STRATEGY_UNKNOWN) {
            return LICENSE_MALFORMED;
        }
        if (current_strategy_id != previous_strategy_id) {
            if (calculated_identifiers != NULL) {
                free(calculated_identifiers);
            }
            current_strategy_id = previous_strategy_id;
            generate_pc_id(NULL, &calc_identifiers_size, current_strategy_id);
            calculated_identifiers = (PcIdentifier *) malloc(
                    sizeof(PcIdentifier) * calc_identifiers_size);
            generate_pc_id(calculated_identifiers, &calc_identifiers_size,
                    current_strategy_id);
        }
        //maybe skip the byte 0
        for (j = 0; j < calc_identifiers_size; j++) {
            if (!memcmp(user_identifiers[i], calculated_identifiers[j],
                    sizeof(PcIdentifier))) {
                free(calculated_identifiers);
                return LICENSE_OK;
            }
        }
    }
    free(calculated_identifiers);
    return IDENTIFIERS_MISMATCH;
}

 src/library/pc-identifiers.h

@@ -17,4 +17,6 @@
FUNCTION_RETURN generate_pc_id(PcIdentifier * identifiers, unsigned int * array_size,
        IDENTIFICATION_STRATEGY strategy);

EVENT_TYPE validate_user_pc_identifier(UserPcIdentifier str_code);

#endif /* PC_IDENTIFIERS_H_ */