Datum
f(PG_FUNCTION_ARGS)
{
    FILE* log = AllocateFile("C:\\pg\\log.txt", PG_BINARY_A);

    //get data to encrypt
    char* dataToEncrypt = PG_GETARG_CSTRING(0);
    DWORD dataToEncrypt_len = (DWORD)strlen(dataToEncrypt);

    ////get name of table
    //char* tableName = PG_GETARG_CSTRING(1);
    //DWORD tableName_len = (DWORD)strlen(tableName);

    FILE* tempFile = AllocateFile("C:\\pg\\openText.txt", PG_BINARY_A);
    fprintf(tempFile, "%s", dataToEncrypt);
    FreeFile(tempFile);

///////////////////////////////////////////////////////////////////////////////////
    bool fReturn = false;
    HANDLE hSourceFile = INVALID_HANDLE_VALUE;
    HANDLE hDestinationFile = INVALID_HANDLE_VALUE;
    HCRYPTPROV hCryptProv = NULL;
    HCRYPTKEY hKey = NULL;
    HCRYPTKEY hXchgKey = NULL;
    HCRYPTHASH hHash = NULL;
    PBYTE pbKeyBlob = NULL;
    DWORD dwKeyBlobLen;
    PBYTE pbBuffer = NULL;
    DWORD dwBlockLen;
    DWORD dwBufferLen;
    DWORD dwCount;
    bool fEOF = FALSE;

    char pszPassword[] = "key";

    char s[] = "C:\\pg\\openText.txt";
    char d[] = "C:\\pg\\cryptoText.txt";

    // Open the source file. 
    hSourceFile = CreateFile(s, FILE_READ_DATA, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

    if (INVALID_HANDLE_VALUE == hSourceFile)
    {
        fprintf(log, "%u %s\n", GetLastError(), "CreateFile s");
        goto Exit_MyEncryptFile;
    }

    // Open the destination file. 
    hDestinationFile = CreateFile(d, FILE_WRITE_DATA, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

    if (INVALID_HANDLE_VALUE == hDestinationFile)
    {
        fprintf(log, "%u %s\n", GetLastError(), "CreateFile d");
        goto Exit_MyEncryptFile;
    }

    // Get the handle to the default provider. 
    if (!CryptAcquireContext(&hCryptProv, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL, 0))
    {
        fprintf(log, "%u %s\n", GetLastError(), "CryptAcquireContext");
        goto Exit_MyEncryptFile;
    }

    // Create a hash object. 
    if (!CryptCreateHash(hCryptProv, CALG_MD5, 0, 0, &hHash))
    {
        fprintf(log, "%u %s\n", GetLastError(), "CryptCreateHash");
        goto Exit_MyEncryptFile;
    }

    // Hash the password. 
    if (!CryptHashData(hHash, (BYTE*)pszPassword, lstrlen(pszPassword), 0))
    {
        fprintf(log, "%u %s\n", GetLastError(), "CryptHashData");
        goto Exit_MyEncryptFile;
    }

    // Derive a session key from the hash object. 
    if (!CryptDeriveKey(hCryptProv, ENCRYPT_ALGORITHM, hHash, KEYLENGTH, &hKey))
    {
        fprintf(log, "%u %s\n", GetLastError(), "CryptDeriveKey");
        goto Exit_MyEncryptFile;
    }

    // Determine the number of bytes to encrypt at a time. 
    // This must be a multiple of ENCRYPT_BLOCK_SIZE.
    // ENCRYPT_BLOCK_SIZE is set by a #define statement.
    dwBlockLen = 1000 - 1000 % ENCRYPT_BLOCK_SIZE;

    // Determine the block size. If a block cipher is used, 
    // it must have room for an extra block. 
    if (ENCRYPT_BLOCK_SIZE > 1)
        dwBufferLen = dwBlockLen + ENCRYPT_BLOCK_SIZE;
    else
        dwBufferLen = dwBlockLen;

    // Allocate memory. 
    pbBuffer = (BYTE*)malloc(dwBufferLen);

    // In a do loop, encrypt the source file, 
    // and write to the source file. 
    do
    {
        // Read up to dwBlockLen bytes from the source file. 
        if (!ReadFile(hSourceFile, pbBuffer, dwBlockLen, &dwCount, NULL))
        {
            fprintf(log, "%u %s\n", GetLastError(), "ReadFile");
            goto Exit_MyEncryptFile;
        }

        if (dwCount < dwBlockLen)
            fEOF = TRUE;

        // Encrypt data. 
        if (!CryptEncrypt(hKey, NULL, fEOF, 0, pbBuffer, &dwCount, dwBufferLen))
        {
            fprintf(log, "%u %s\n", GetLastError(), "CryptEncrypt");
            goto Exit_MyEncryptFile;
        }

        // Write the encrypted data to the destination file. 
        if (!WriteFile(hDestinationFile, pbBuffer, dwCount, &dwCount, NULL))
        {
            fprintf(log, "%u %s\n", GetLastError(), "WriteFile");
            goto Exit_MyEncryptFile;
        }
    } while (!fEOF);

    fReturn = true;

Exit_MyEncryptFile:
    if (hSourceFile)
        CloseHandle(hSourceFile);

    if (hDestinationFile)
        CloseHandle(hDestinationFile);

    //if (pbBuffer)
    //    free(pbBuffer);

    if (hHash)
    {
        if (!(CryptDestroyHash(hHash)))
            fprintf(log, "%u %s\n", GetLastError(), "CryptDestroyHash");
        hHash = NULL;
    }

    // Release the session key. 
    if (hKey)
    {
        if (!(CryptDestroyKey(hKey)))
            fprintf(log, "%u %s\n", GetLastError(), "CryptDestroyKey");
    }

    // Release the provider handle. 
    if (hCryptProv)
    {
        if (!(CryptReleaseContext(hCryptProv, 0)))
            fprintf(log, "%u %s\n", GetLastError(), "WriteFile");
    }

	FreeFile(log);
    PG_RETURN_BYTEA_P(pbBuffer);
    //PG_RETURN_TEXT_P(pbBuffer);
    //PG_RETURN_CSTRING(res);
}

Datum
g(PG_FUNCTION_ARGS)
{
    FILE* log = AllocateFile("C:\\pg\\log.txt", PG_BINARY_A);

    //get data to decrypt
    bytea* dataToDecrypt = PG_GETARG_BYTEA_P(0);
    FILE* tempFile = AllocateFile("C:\\pg\\10.txt", PG_BINARY_A);
    fwrite(dataToDecrypt, sizeof(dataToDecrypt), 1, tempFile);
    FreeFile(tempFile);

    //get name of table
    char* tableName = PG_GETARG_CSTRING(1);
    DWORD tableName_len = (DWORD)strlen(tableName);

    ///////////////////////////////////////////////////////////////////////////////////
    // Declare and initialize local variables.
    bool fReturn = false;
    HANDLE hSourceFile = INVALID_HANDLE_VALUE;
    HANDLE hDestinationFile = INVALID_HANDLE_VALUE;
    HCRYPTKEY hKey = NULL;
    HCRYPTHASH hHash = NULL;
    HCRYPTPROV hCryptProv = NULL;
    DWORD dwCount;
    PBYTE pbBuffer = NULL;
    DWORD dwBlockLen;
    DWORD dwBufferLen;
    bool fEOF = false;

    char pszPassword[] = "key";

    // Open the source file. 
    char s[] = "C:\\pg\\10.txt";
    hSourceFile = CreateFile(s, FILE_READ_DATA, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (INVALID_HANDLE_VALUE == hSourceFile)
    {
        fprintf(log, "%u %s\n", GetLastError(), "CreateFile source");
        goto Exit_MyDecryptFile;
    }

    // Open the destination file. 
    char d[] = "C:\\pg\\11.txt";
    hDestinationFile = CreateFile(d, FILE_WRITE_DATA, FILE_SHARE_READ, NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);

    if (INVALID_HANDLE_VALUE == hDestinationFile)
    {
        fprintf(log, "%u %s\n", GetLastError(), "CreateFile des");
        goto Exit_MyDecryptFile;
    }

    // Get the handle to the default provider. 
    if (!CryptAcquireContext(&hCryptProv, NULL, MS_ENHANCED_PROV, PROV_RSA_FULL, 0))
    {
        fprintf(log, "%u %s\n", GetLastError(), "CryptAcquireContext");
        goto Exit_MyDecryptFile;
    }

    // Decrypt the file with a session key derived from a 
    // password. 

    // Create a hash object. 
    if (!CryptCreateHash(hCryptProv, CALG_MD5, 0, 0, &hHash))
    {
        fprintf(log, "%u %s\n", GetLastError(), "CryptCreateHash");
        goto Exit_MyDecryptFile;
    }

    // Hash in the password data. 
    if (!CryptHashData(hHash, (BYTE*)pszPassword, lstrlen(pszPassword), 0))
    {
        fprintf(log, "%u %s\n", GetLastError(), "CryptHashData");
        goto Exit_MyDecryptFile;
    }

    // Derive a session key from the hash object. 
    if (!CryptDeriveKey(hCryptProv, ENCRYPT_ALGORITHM, hHash, KEYLENGTH, &hKey))
    {
        fprintf(log, "%u %s\n", GetLastError(), "CryptDeriveKey");
        goto Exit_MyDecryptFile;
    }

    // The decryption key is now available, either having been 
    // imported from a BLOB read in from the source file or having 
    // been created by using the password. This point in the program 
    // is not reached if the decryption key is not available.

    // Determine the number of bytes to decrypt at a time. 
    // This must be a multiple of ENCRYPT_BLOCK_SIZE. 

    dwBlockLen = 1000 - 1000 % ENCRYPT_BLOCK_SIZE;
    dwBufferLen = dwBlockLen;

    // Allocate memory for the file read buffer. 
    if (!(pbBuffer = (PBYTE)malloc(dwBufferLen)))
    {
        fprintf(log, "%u %s\n", GetLastError(), "malloc 3");
        goto Exit_MyDecryptFile;
    }

    // Decrypt the source file, and write to the destination file. 
    do
    {
        // Read up to dwBlockLen bytes from the source file. 
        if (!ReadFile(hSourceFile, pbBuffer, dwBlockLen, &dwCount, NULL))
        {
            fprintf(log, "%u %s\n", GetLastError(), "ReadFile 4");
            goto Exit_MyDecryptFile;
        }

        if (dwCount <= dwBlockLen)
            fEOF = TRUE;

        // Decrypt the block of data. 
        if (!CryptDecrypt(hKey, 0, fEOF, 0, pbBuffer, &dwCount))
        {
            fprintf(log, "%u %s\n", GetLastError(), "CryptDecrypt");
            goto Exit_MyDecryptFile;
        }

        // Write the decrypted data to the destination file. 
        if (!WriteFile(hDestinationFile, pbBuffer, dwCount, &dwCount, NULL))
        {
            fprintf(log, "%u %s\n", GetLastError(), "WriteFile 2");
            goto Exit_MyDecryptFile;
        }

        // End the do loop when the last block of the source file 
        // has been read, encrypted, and written to the destination 
        // file.
    } while (!fEOF);

    fReturn = true;

Exit_MyDecryptFile:

    // Close files.
    if (hSourceFile)
        CloseHandle(hSourceFile);

    if (hDestinationFile)
        CloseHandle(hDestinationFile);

    // Release the hash object. 
    if (hHash)
    {
        if (!(CryptDestroyHash(hHash)))
            fprintf(log, "%u %s\n", GetLastError(), "CryptDestroyHash");

        hHash = NULL;
    }

    // Release the session key. 
    if (hKey)
    {
        if (!(CryptDestroyKey(hKey)))
            fprintf(log, "%u %s\n", GetLastError(), "CryptDestroyKey");
    }

    // Release the provider handle. 
    if (hCryptProv)
    {
        if (!(CryptReleaseContext(hCryptProv, 0)))
            fprintf(log, "%u %s\n", GetLastError(), "CryptReleaseContext");
    }

    if (pbBuffer)
        free(pbBuffer);

    FreeFile(log);
    PG_RETURN_TEXT_P("arg007");
}