#include <iostream>

using namespace std;

class Base{
public:
    virtual void vf1(){cout<< "call Base vf1()"<<endl;}
    void f1(){cout<<"call Base f1()"<<endl;}
};
class Derived: public Base{
public:
    virtual void vf1(){cout <<"call Derived vf1()"<<endl;}
    virtual void vf2(){cout <<"call Derived vf2()"<<endl;}
    void f1(){cout<<"call Derived f1()"<<endl;}         
};
void func(Base* obj){
    cout<<"the class is "<<typeid(*obj).name()<<endl;  // 真实的类型：the class is 7Derived
    obj->f1();  // 非多态：call Base f1()
    obj->vf1(); // 多态：call Derived vf1()
    if(typeid(*obj)== typeid(Derived)){
        dynamic_cast<Derived*>(obj)->vf2();  // 派生类转换：call Derived vf2()
    }
}
int main() {
    Derived a;
    a.f1(); // 正常：call Derived f1()
    func(&a);
    return 0;
}

#include "stdafx.h"
#include "..."
#include<iostream>
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    Interface * Ivar = NULL;
    HRESULT hr = CoInitialize(NULL);

    if(SUCCEEDED(hr))
    {
        hr = CoCreateInstance(CLSID,
            NULL,
            CLSCTX_INPROC_SERVER,
            IID,
            (void **)&Ivar);
        if(SUCCEEDED(hr))
        {
            Ivar->Func(...);
            Ivar->Release();
        }
        else
        {
            cout << "CoCreateInstance Failed." << endl;
        }
    }
    CoUninitialize();
    return 0;
}

import gmpy2

RSA_SK = '''-----BEGIN RSA PRIVATE KEY-----
MIIBOgIBAAJBAPEKGpuWnpXu+bfWMM2LpXpZR/R5DhXbCSJBWNLgOlOqCzNws/lj
VE/oOdtsULWuQSmhn4tzXsLZETsRoH73HUMCAwEAAQJAQmiOPB+bQaO9mTCh8X9v
7+15LZnMj6jxM0bdufudFj9SOlO/XRzdgx4Z/uK5D1JrtlSGcgs5OmgrGF+SFtAq
AQIhAP7V1mPs/HckwQpMIAdAOVV15PYnv3IAVlWKhYm8LrljAiEA8iQgBES2ypEv
Kpydf/y5KNPVNQkqhVmSpeeFP53jQqECIBVv1ZYYVHCNVfPQzYzumSQYQ8d1NoSX
hKuzeGJKwz9zAiBmXqV2iIJrE4RIVJw1rues/hnGaVCjveHE6COqaJra4QIhALbC
Mwv9nvECYbAM1Gm05eC1p7pARhcfUiK5vWQ9fqv8
-----END RSA PRIVATE KEY-----'''
# openssl genrsa 512
PKCS_MAGIC = bytes.fromhex('0001FFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF FFFFFF00')


def bignum_to_bytes(num: int, pad: int = 0) -> bytes:
    """将大数按大端序转换为字节序列"""
    hexstr = hex(num)[2:]
    hexstr = '0' + hexstr if len(hexstr) % 2 else hexstr
    hex_arr = [int(hexstr[i: i + 2], 16) for i in range(0, len(hexstr), 2)]
    hex_arr.reverse()
    if pad and len(hex_arr) != pad:
        hex_arr.extend([0] * (pad - len(hex_arr)))
    hex_arr.reverse()
    return bytes(hex_arr)


def bytes_to_bignum(data: bytes) -> int:
    """解析大端序存储的大数"""
    data_arr = list(map(lambda b: f"{b:02X}", data))
    return int(''.join(data_arr), 16)


def rsa512_pkcs_v1_5_encrypt(d: int, N: int, data: bytes) -> int:
    """精简版的加密"""
    assert len(data) == 32
    M = PKCS_MAGIC + data
    M = bytes_to_bignum(M)
    return int(gmpy2.powmod(M, d, N))


def rsa512_pkcs_v1_5_decrypt(e: int, N: int, data: bytes) -> bytes:
    assert len(data) == 64
    C = bytes_to_bignum(data)
    M = gmpy2.powmod(C, e, N)
    M = bignum_to_bytes(M, 64)
    assert M[0:32] == PKCS_MAGIC and len(M) == 64
    M = M[32:]
    print(bytelist_to_hexstr(M))
    return M

import ideacipher

BLOCK_SIZE = 8
def idea_decrypt(key: bytes, ciphertext: bytes) -> bytes:
    plaintext = b''
    for i in range(0, len(ciphertext), BLOCK_SIZE):
        block = ciphertext[i:i + BLOCK_SIZE]
        if len(block) == BLOCK_SIZE:
            plaintext += bytes(ideacipher.decrypt(block, key))
        else:
            for b in block:
                plaintext += struct.pack('<B', (b ^ 0xc5) & 0xff)
    return plaintext


def idea_encrypt(key: bytes, plaintext: bytes) -> bytes:
    cipher = b''
    for i in range(0, len(plaintext), BLOCK_SIZE):
        block = plaintext[i:i + BLOCK_SIZE]
        if len(block) == BLOCK_SIZE:
            cipher += bytes(ideacipher.encrypt(block, key))
        else:
            for b in block:
                cipher += struct.pack('<B', (b ^ 0xc5) & 0xff)
    return cipher

def pack_str(s: str) -> bytes:
    """将字符串打包"""
    num = len(s)
    assert num < 0xffffffff
    if num < 0xff:
        return struct.pack('<B', num) + s.encode()
    else:
        return b'\xff' + struct.pack('>I', num) + s.encode()


def seralize_node(node) -> bytes:
    out = b''
    if isinstance(node, dict):
        out += b'\x0c'
        out += struct.pack('<B', len(node))
        for k, v in node.items():
            out += pack_str(k)
            out += seralize_node(v)
    elif isinstance(node, (list, tuple)):
        for v in node:
            out += seralize_node(v)
    elif isinstance(node, str):
        out += b'\x06'
        out += pack_str(node)
    elif isinstance(node, int):
        out += b'\x03'
        out += struct.pack('>I', node)
    elif isinstance(node, DateTime):
        out += b'\x0a'
        out += node.seralize()
    elif isinstance(node, bool):
        if node:
            out += b'\x01'
        else:
            out += b'\x02'
    else:
        raise NotImplemented('S')
    return out


def seralize2(json_data):
    data = struct.pack('>IHH', 0xffffffff, 0x01, 0x02) + seralize_node(json_data)  # flag + type + version
    return data

sed -bi 's/...(原始公钥).../\xF1\x0A\x1A...'

def gen_lic(json_data):
    # 序列化数据
    data = struct.pack('>I', 0xffffffff) + seralize2(json_data)
    print('证书内容：', data)
    # 计算MD5
    checksum = md5()
    checksum.update(data)
    checksum = checksum.hexdigest()
    print('校验和：', checksum)
    checksum = hexstr_to_bytelist(checksum)
    # 对称加密
    idea_key = '000100020c024544000100020c024544'
    idea_key = hexstr_to_bytelist(idea_key)
    data = idea_encrypt(idea_key, data)
    print('密文：', bytelist_to_hexstr(data).replace(' ', ''))
    # 非对称加密
    rsa_plaintext = idea_key + checksum
    RSA_KEYPAIR = RSA.importKey(RSA_SK)
    N = RSA_KEYPAIR.n
    e = RSA_KEYPAIR.e
    d = RSA_KEYPAIR.d
    rsa_cipher = rsa512_pkcs_v1_5_encrypt(d, N, rsa_plaintext)
    print('RSA N: ', bytelist_to_hexstr(bignum_to_bytes(N, 64)))
    print('RSA e: ', bytelist_to_hexstr(bignum_to_bytes(e, 32)))
    print('RSA d: ', bytelist_to_hexstr(bignum_to_bytes(d, 32)))
    data = bignum_to_bytes(rsa_cipher, 64) + data
    # base64编码
    data = base64.b64encode(data)
    print('证书: ', data.decode())
    print('编码后证书: ', quote_from_bytes(data, safe=''))