main.cpp

#include "resource.h"

#include <WS2tcpip.h>
#include <iostream>
#include <stdio.h>
#include <map>
#include <bitset>
#include <vector>

#pragma comment(lib, "ws2_32.lib")

HWND mainWindow, hwnd;
unsigned long sock;

char emailid[256];
char pwd[256];
char to[256];
char subject[256];
char content[1024];
char sendmsg[256];
char recvmsg[256];

std::map<int, char> base;
int ret = 0;

/*read the Base64 Wikipedia article to understand this.


Basic concept: Convert each ascii letter into binary. group them into 6's and lookup in base64 table.*/

std::vector<int> get_base64_int(char *email)
{
    //char email[] = "Man";
    char buff[32];
    std::vector<std::string> codes;
    std::vector<std::string> broken_codes;
    std::string temp, temp2;
    std::vector<std::string>::iterator it;

    memset(buff, 0, 32);

    for(int i = 0; i < strlen(email); i++)
    {
        //itoa((int)email[i], buff, 2);
        std::bitset<sizeof(int) * CHAR_BIT> bits((int)email[i]); //decimal to binary
        temp.assign(bits.to_string());
        codes.push_back(temp.substr(temp.length() - 8, 8)); //this returns 4 bytes. So get the last byte which is our binary code.
    }

    ret = codes.size() % 3; //check if it is divisible by 3. This is for adding the padding (read the article seriously).

    if(ret != 0)
    {
        if(ret == 1)
        {
            codes.push_back("00000000");
            codes.push_back("00000000");
        }
        else if(ret == 2)
            codes.push_back("00000000");
    }

    for(it = codes.begin(); it != codes.end(); it++)
        temp2 += (*it).c_str(); //combine all the binarycodes into one string.

    int multiple = 0;

    while(multiple < temp2.size())
    {
        broken_codes.push_back(temp2.substr(multiple, 6).data()); //the string needs to be broken into 6 to be converted to decimal.
        multiple += 6;
    }

    std::vector<int> full_codes;


    for(it = broken_codes.begin(); it != broken_codes.end(); it++) //convert each 6 digit binary code to a decimal.
    {
        int x = 0, r = 0, j = 1, d = 0;
        x = atoi((*it).c_str());
        while(x != 0)
        {
            r = x % 10;
            d = d + r * j;
            j = j * 2;
            x = x / 10;
        }

        full_codes.push_back(d); //push all the digits.
    }

    return full_codes;
}

std::string get_encrypted_string(char *str)
{
    std::vector<int> base64_bin = get_base64_int(str);
    std::string encrypted_string;
    for(int i = 0; i < base64_bin.size(); i++)
    {
        encrypted_string += base[base64_bin.at(i)];
    }

    encrypted_string = encrypted_string.substr(0, (encrypted_string.size() - (ret == 0 ? 0 : (ret == 1 ? 2 : 1))));
    encrypted_string += std::string((ret == 0 ? 0 : (ret == 1 ? 2 : 1)), '=');
    return encrypted_string;
}

void send_msg(char *msg)
{
    memset(&sendmsg, 0, 256);
    strcat(sendmsg, msg);
    if(send(sock, sendmsg, strlen(sendmsg), 0) == SOCKET_ERROR)
        MessageBox(NULL, "send()", "Error", MB_OK | MB_ICONERROR);
}

void recv_msg()
{
    memset(&recvmsg, 0, 256);
    if(recv(sock, recvmsg, 256, 0) == SOCKET_ERROR)
        MessageBox(NULL, "recv()", "Error", MB_OK | MB_ICONERROR);
    else
        SetWindowText(hwnd, recvmsg);
}

BOOL CALLBACK MainProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch(uMsg)
    {
        case WM_INITDIALOG:
        {
            hwnd = hWnd;
            SetDlgItemText(hWnd, ID_EMAIL, "Your Account EMail");
            SetDlgItemText(hWnd, ID_PWD, "Your Account Password");
            SetDlgItemText(hWnd, ID_TO, "To Email Address");
            SetDlgItemText(hWnd, ID_SUB, "Subject");
            SetDlgItemText(hWnd, ID_DATA, "Your Message");

            memset(&emailid, 0, 256);
            memset(&pwd, 0, 256);
            memset(&to, 0, 256);
            memset(&subject, 0, 256);
            memset(&content, 0, 1024);


            break;
        }
        case WM_COMMAND:
        {
            switch(LOWORD(wParam))
            {
                case BTN_SEND:
                {
                    WSADATA wsaData;
                    if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
                    {
                        MessageBox(hWnd, "WSAStartup()", "Error", MB_OK | MB_ICONERROR);
                        exit(0);
                    }
                    else
                    {
                        sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
                        if(sock == INVALID_SOCKET)
                        {
                            MessageBox(hWnd, "socket()", "Error", MB_OK | MB_ICONERROR);
                            exit(0);
                        }
                        else
                        {
                            sockaddr_in sin;
                            hostent* server = gethostbyname("smtp.gmail.com");
                            memcpy((void*)&sin.sin_addr.S_un.S_addr, (void*)server->h_addr, server->h_length);
                            sin.sin_port = htons(587);
                            sin.sin_family = AF_INET;

                            if(connect(sock, (sockaddr*)&sin, sizeof(sin)) == SOCKET_ERROR)
                            {
                                MessageBox(hWnd, "connect()", "Error", MB_OK | MB_ICONERROR);
                                exit(0);
                            }
                            else
                            {
                                SetWindowText(hWnd, "Connected!");
                                send_msg("EHLO mail.gmail.com\r\n"); //EHLO comman.d.
                                recv_msg();
                                Sleep(1000);
                                send_msg("AUTH LOGIN\r\n");
                                recv_msg();
                                for(int i = 0; i < 26; i++)
                                base[i] = ((char)i + 65); //A-Z
                                for(int i = 26; i < 52; i++)
                                    base[i] = ((char)(i + 71)); //a-z
                                for(int i = 52; i < 61; i++)
                                {
                                    char c[10];
                                    itoa(i - 52, c, 10);
                                    base[i] = c[0];
                                }
                                base[61] = '9';
                                base[62] = '+';
                                base[63] = '/';
                                base[64] = '=';
                            }


                        }
                    }
                    GetDlgItemText(hWnd, ID_EMAIL, emailid, 256);
                    std::string emailidd = get_encrypted_string(emailid);
                    emailidd += "\r\n";
                    send_msg((char *)emailidd.c_str());
                    recv_msg();

                    GetDlgItemText(hWnd, ID_PWD, pwd, 256);
                    std::string pwdd = get_encrypted_string(pwd);
                    pwdd += "\r\n";
                    send_msg((char *)pwdd.c_str());

                    memset(pwd, 0, 256);
                    sprintf(pwd, "MAIL FROM: <%s>\r\n", emailid);
                    send_msg(pwd);
                    recv_msg();

                    memset(pwd, 0, 256);
                    GetDlgItemText(hWnd, ID_TO, to, 256);
                    sprintf(pwd, "rcpt to: <%s>\r\n", to);
                    send_msg(pwd);

                    recv_msg();
                    send_msg("DATA\r\n");
                    recv_msg();

                    memset(pwd, 0, 256);
                    sprintf(pwd, "From: %s\r\n", emailid);
                    send_msg(pwd);

                    memset(pwd, 0, 256);
                    sprintf(pwd, "To: %s\r\n", to);
                    send_msg(pwd);


                    GetDlgItemText(hWnd, ID_SUB, subject, 256);
                    memset(pwd, 0, 256);
                    sprintf(pwd, "Subject: %s\r\n", subject);
                    send_msg(pwd);

                    GetDlgItemText(hWnd, ID_DATA, content, 1024); //buffer overflow problem.

                    send_msg("\r\n");
                    strcat(content, "\r\n");
                    send_msg(content);
                    send_msg(".\r\n");
                    recv_msg();
                    MessageBox(NULL, "Message has been sent.", "Simple EMailer -Sri Krishna", MB_OK);
                    break;
                }
            }
            break;
        }
        case WM_CLOSE:
        {
            closesocket(sock);
            EndDialog(hWnd, WM_CLOSE);
            break;
        }
        default:
            return false;
    }
    true;
}

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR nCmdLine, int nCmdShow)
{
    return DialogBox(GetModuleHandle(NULL), MAKEINTRESOURCE(DIALOG_BOX), mainWindow, MainProc);
}