From 1a5a193a36cc98a89a1c284fa41554dcf9bc8b86 Mon Sep 17 00:00:00 2001
From: Luca Conte <main@lugico.de>
Date: Tue, 18 Mar 2025 22:37:32 +0100
Subject: [PATCH] initial commit

---
 install           |  34 +++++
 source/main.cpp   | 368 ++++++++++++++++++++++++++++++++++++++++++++++
 source/sha512.cpp | 155 +++++++++++++++++++
 source/sha512.h   |  71 +++++++++
 uninstall         |  12 ++
 5 files changed, 640 insertions(+)
 create mode 100755 install
 create mode 100644 source/main.cpp
 create mode 100644 source/sha512.cpp
 create mode 100644 source/sha512.h
 create mode 100755 uninstall

diff --git a/install b/install
new file mode 100755
index 0000000..8217001
--- /dev/null
+++ b/install
@@ -0,0 +1,34 @@
+#!/bin/bash
+
+if [ $(id -u) != "0" ]
+then
+	sudo sh install || echo "Make shure your working directory is the same as the one this file and the source folder is located in."
+	exit $?
+fi
+
+echo "Checking Ncurses"
+check_ncurses=$(dpkg -l | grep libncurses5-dev | wc -l)
+if [ $check_ncurses -le 0 ]
+then
+	echo "\e[91mNcurses is not installed but is required for xLock.\e[0m"
+	echo "use 'sudo apt-get install libncurses5-dev libncursesw5-dev' to install it."
+	exit
+else
+	echo "Ncurses is already installed. Skipping"
+fi
+
+echo "Checking g++"
+check_ncurses=$(dpkg -l | grep g++ | wc -l)
+if [ $check_ncurses -le 0 ]
+then
+	echo "\e[91mg++ is not installed but is required for xLock.\e[0m"
+	echo "use 'sudo apt-get install g++' to install it."
+	exit
+else
+	echo "g++ is already installed. Skipping"
+fi
+echo "Compiling"
+g++ -o /usr/bin/xlock source/main.cpp source/sha512.cpp -lncurses -std=c++11
+
+echo "\033[92mInstallation complete\033[0m"
+echo "Use 'xlock chpw' to set/change your password."
diff --git a/source/main.cpp b/source/main.cpp
new file mode 100644
index 0000000..54c5541
--- /dev/null
+++ b/source/main.cpp
@@ -0,0 +1,368 @@
+#include <string>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <pwd.h>
+#include <unistd.h>
+#include <iostream>
+#include <csignal>
+#include <fstream>
+#include <vector>
+#include <ncurses.h>
+#include <time.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include "sha512.h"
+
+#define WAIT_TICK 10000
+
+using namespace std;
+
+WINDOW *wnd;
+
+string pw="";
+char pwchar='*';
+bool randomchar=true;
+bool exit_requested=false;
+bool changepassword=false;
+bool softlock=false;
+
+int pwfieldlength=40;
+
+int LINES;
+int COLS;
+
+vector<string> quitmsgs;
+vector<string> wrongmsgs;
+
+string pwpath="";
+string pwhash="3c9909afec25354d551dae21590bb26e38d53f2173b8d3dc3eee4c047e7ab1c1eb8b85103e3be7ba613b31bb5c9c36214dc9f14a42fd7a2fdb84856bca5c44c2";
+
+int init() {
+	srand(time(NULL));
+	fstream f(pwpath, ios::in);
+	if (f.good()) {
+		getline(f, pwhash);
+		if (pwhash.length()<20) {
+			cerr << "Error: passwd file not correctly formatted." << endl;
+			exit(1);
+		}
+	} else {
+		cerr << "Error while loading password file." << endl;
+		exit(1);
+	}
+	f.close();
+
+	initscr();
+	wnd=newwin(0,0,0,0);
+	
+	getmaxyx(wnd,LINES,COLS);
+
+	noecho();
+	clear();
+
+	keypad(wnd, true);
+
+	//curs_set(0);
+
+	start_color();
+
+	init_pair(1,COLOR_WHITE, COLOR_BLACK);
+	init_pair(2,COLOR_WHITE, COLOR_BLUE);
+	init_pair(3,COLOR_RED, COLOR_BLACK);
+
+	bkgd(COLOR_PAIR(1));
+
+	string enterpw="Enter password:";
+	for (int i=0; i<enterpw.length(); i++) {
+		mvaddch(LINES/2-2,COLS/2-enterpw.length()/2+i,enterpw[i]);
+	}
+	
+	for (int i=0; i<pwfieldlength; i++) {
+		mvaddch(LINES/2,COLS/2-pwfieldlength/2+i,' ' | COLOR_PAIR(2));
+	}
+	move(LINES/2,COLS/2-pwfieldlength/2);
+	wrefresh(wnd);
+
+	return 0;
+}
+
+void handler(int signum)
+{
+	if (changepassword || softlock) {
+		echo();
+		endwin();
+		exit(1);
+	} else {
+		for (int i=0; i<COLS; i++) {
+			mvaddch(LINES/2+2,i,' ');
+		}
+		int printindex=rand() % quitmsgs.size();
+		string str=quitmsgs[printindex];
+		attron(A_BOLD);
+		for (int i=0; i<str.length(); i++) {
+			mvaddch(LINES/2 + 2, COLS/2 - str.length()/2+i, str[i] | COLOR_PAIR(3));
+		}
+		attroff(A_BOLD);
+		if (pw.length()<pwfieldlength) {
+			move(LINES/2,COLS/2-pwfieldlength/2+pw.length());
+		} else {
+			move(LINES/2,COLS/2+pwfieldlength/2);
+		}
+		refresh();
+	}
+}
+
+void checkpw() {
+	string crypt=sha512(pw);
+	if (crypt!= pwhash) {
+		if (!changepassword && !softlock) {
+			usleep(1000000);
+			for (int i=0; i<COLS; i++) {
+				mvaddch(LINES/2+2,i,' ');
+			}
+			int printindex=rand() % wrongmsgs.size();
+			string str=wrongmsgs[printindex];
+			attron(A_BOLD);
+			for (int i=0; i<str.length(); i++) {
+				mvaddch(LINES/2+2,COLS/2-str.length()/2+i,str[i] | COLOR_PAIR(3));
+			}
+			attroff(A_BOLD);
+			if (pw.length()<pwfieldlength) {
+				move(LINES/2,COLS/2-pwfieldlength/2+pw.length());
+			} else {
+				move(LINES/2,COLS/2+pwfieldlength/2);
+			}
+			refresh();
+			pw="";
+		} else {
+			usleep(1000000);
+			echo();
+			endwin();
+			cerr << "Wrong password!" << endl;
+			exit(1);
+		}
+	} else {
+		exit_requested=true;
+		endwin();
+		if (!changepassword) {
+			exit(0);
+		}
+	}
+}
+
+void run() {
+	while(!exit_requested) {
+		if (cin.eof()) {}
+
+		int in_char=getch();
+
+		for (int i=0; i<COLS; i++) {
+			mvaddch(LINES/2+2,i,' ');
+		}
+		if (in_char==263 || in_char==330 || in_char=='\b' || in_char==127) {  //  BACKSPACE
+			pw=pw.substr(0,pw.size()-1);
+		} else if (in_char == 10 || in_char=='\n') {             //ENTER
+			checkpw();
+		} else {                               //LETTERS
+			pw = pw + (char)in_char;
+		}
+		for (int i=0; i<pwfieldlength; i++) {
+			if (i<pw.length()) {
+				if (randomchar) {
+					char ch = (char) (rand() % 93 + 33);
+					mvaddch(LINES/2,COLS/2-pwfieldlength/2+i,ch | COLOR_PAIR(2));
+				} else {
+					mvaddch(LINES/2,COLS/2-pwfieldlength/2+i,pwchar | COLOR_PAIR(2));
+				}
+			} else {
+				mvaddch(LINES/2,COLS/2-pwfieldlength/2+i,' ' | COLOR_PAIR(2));
+			}
+		}
+		if (pw.length()<pwfieldlength) {
+			move(LINES/2,COLS/2-pwfieldlength/2+pw.length());
+		} else {
+			move(LINES/2,COLS/2+pwfieldlength/2);
+		}
+		usleep(WAIT_TICK);
+		refresh();
+	}
+	checkpw();
+}
+
+
+string readPw(string msg) {
+	initscr();
+	wnd=newwin(0,0,0,0);
+	getmaxyx(wnd,LINES,COLS);
+
+	noecho();
+	clear();
+
+	keypad(wnd, true);
+
+	//curs_set(0);
+
+	start_color();
+
+	init_pair(1,COLOR_WHITE, COLOR_BLACK);
+	init_pair(2,COLOR_WHITE, COLOR_BLUE);
+
+	pw="";
+	bkgd(COLOR_PAIR(1));
+	exit_requested=false;
+
+	for (int i=0; i<msg.length(); i++) {
+		mvaddch(LINES/2-2, COLS/2-msg.length()/2+i,msg[i]);
+	}
+	for (int i=0; i<pwfieldlength; i++) {
+		if (i<pw.length()) {
+			if (randomchar) {
+				char ch = (char)(rand() % 93 + 33);
+				mvaddch(LINES/2,COLS/2-pwfieldlength/2+i,ch | COLOR_PAIR(2));
+			} else {
+				mvaddch(LINES/2,COLS/2-pwfieldlength/2+i,pwchar | COLOR_PAIR(2));
+			}
+		} else {
+			mvaddch(LINES/2,COLS/2-pwfieldlength/2+i,' ' | COLOR_PAIR(2));
+		}
+	}
+	for (int i=0; i<COLS; i++) {
+		mvaddch(LINES/2+2,i,' ');
+	}
+	if (pw.length()<pwfieldlength) {
+		move(LINES/2,COLS/2-pwfieldlength/2+pw.length());
+	} else {
+		move(LINES/2,COLS/2+pwfieldlength/2);
+	}
+	refresh();
+	while(!exit_requested) {
+		if (cin.eof()) {}
+
+		int in_char=getch();
+
+		if (in_char==263 || in_char==330 || in_char=='\b' || in_char==127) {  //  BACKSPACE
+			pw=pw.substr(0,pw.size()-1);
+		} else if (in_char == 10 || in_char=='\n') {             //ENTER
+			echo();
+			endwin();
+			return pw;
+		} else {                               //LETTERS
+			pw= pw + (char)in_char;
+		}
+		for (int i=0; i<pwfieldlength; i++) {
+			if (i<pw.length()) {
+				if (randomchar) {
+					char ch = (char)(rand() % 93 + 33);
+					mvaddch(LINES/2,COLS/2-pwfieldlength/2+i,ch | COLOR_PAIR(2));
+				} else {
+					mvaddch(LINES/2,COLS/2-pwfieldlength/2+i,pwchar | COLOR_PAIR(2));
+				}
+			} else {
+				mvaddch(LINES/2,COLS/2-pwfieldlength/2+i,' ' | COLOR_PAIR(2));
+			}
+		}
+		for (int i=0; i<COLS; i++) {
+			mvaddch(LINES/2+2,i,' ');
+		}
+		if (pw.length()<pwfieldlength) {
+			move(LINES/2,COLS/2-pwfieldlength/2+pw.length());
+		} else {
+			move(LINES/2,COLS/2+pwfieldlength/2);
+		}
+		usleep(WAIT_TICK);
+		refresh();
+	}
+	return "";
+}
+
+
+int main(int argc, char* argv[]) {
+
+	srand(time(0));
+
+	quitmsgs.push_back("There is no escape.");
+	quitmsgs.push_back("No quitting.");
+	quitmsgs.push_back("Ctrl + C wont save you.");
+	quitmsgs.push_back("Try once more?");
+	quitmsgs.push_back("Maby it'll work next time.");
+	quitmsgs.push_back("Dont even bother.");
+	quitmsgs.push_back("No password, no sauce.");
+	quitmsgs.push_back("No. Just... No.");
+	quitmsgs.push_back("User used QUIT. It is not very effective.");
+	quitmsgs.push_back("Gotta try something else bud.");
+	quitmsgs.push_back("You need to try harder!");
+	quitmsgs.push_back("Pathetic.");
+
+	wrongmsgs.push_back("That password was wrong.");
+	wrongmsgs.push_back("Wrong password.");
+	wrongmsgs.push_back("Try again. I dare you!");
+	wrongmsgs.push_back("Wow that better not be your real password");
+	wrongmsgs.push_back("Nope.");
+	wrongmsgs.push_back("Try harder!");
+	wrongmsgs.push_back("That was almost correct. Not.");
+	wrongmsgs.push_back("Please let this not be your actual password.");
+	wrongmsgs.push_back("Seriously?");
+
+	signal(SIGINT, handler);
+	signal(SIGTSTP, handler);
+	signal(SIGABRT, handler);
+	signal(SIGSTOP, handler);
+	signal(SIGQUIT, handler);
+
+	struct passwd *pw = getpwuid(getuid());
+	string homedir=pw->pw_dir;
+	pwpath=homedir + "/.xlockpw";
+
+	if (argc<=1) {
+		init();
+		run();
+	} else if (argc==2) {
+		if (string(argv[1])=="chpw") {
+			changepassword=true;
+			fstream f1(pwpath, ios::in);
+			if (f1.good()) {
+				init();
+				run();
+			}
+			f1.close();
+			string p1;
+			string p2;
+			/*
+			cout << endl << "Enter new password: ";
+			getline(cin,p1);
+			cout << endl << "Repeat password: ";
+			getline(cin,p2);
+			*/
+			p1=readPw("Enter a Password:");
+			p2=readPw("Repeat Password:");
+			if (p1==p2) {
+				ofstream f;
+				f.open(pwpath, std::ofstream::out | std::ofstream::trunc);
+				if (f.good()) {
+					f << sha512(p1);
+				} else {
+					cerr << "Error while loading password file." << endl;
+					cerr << "170" << endl;
+					exit(1);
+				}
+				chmod((char *)pwpath.c_str(),0600);
+				f.close();
+				cout << endl << "Password updated." << endl;
+			} else {
+				cerr << "Passwords do not match";
+			}
+		} else if (string(argv[1])=="soft") {
+			softlock=true;
+			init();
+			run();	
+		} /*else if (string(argv[1])=="read") {
+			cout << readPw("Enter Password:") << endl;	
+		}*/ else {
+			cerr << "unknown argument." << endl;
+		}
+	} else {
+		cerr << "too many arguments" << endl;
+	}
+}
+
diff --git a/source/sha512.cpp b/source/sha512.cpp
new file mode 100644
index 0000000..01fab70
--- /dev/null
+++ b/source/sha512.cpp
@@ -0,0 +1,155 @@
+#include <cstring>
+#include <fstream>
+#include "sha512.h"
+ 
+const unsigned long long SHA512::sha512_k[80] = //ULL = uint64
+            {0x428a2f98d728ae22ULL, 0x7137449123ef65cdULL,
+             0xb5c0fbcfec4d3b2fULL, 0xe9b5dba58189dbbcULL,
+             0x3956c25bf348b538ULL, 0x59f111f1b605d019ULL,
+             0x923f82a4af194f9bULL, 0xab1c5ed5da6d8118ULL,
+             0xd807aa98a3030242ULL, 0x12835b0145706fbeULL,
+             0x243185be4ee4b28cULL, 0x550c7dc3d5ffb4e2ULL,
+             0x72be5d74f27b896fULL, 0x80deb1fe3b1696b1ULL,
+             0x9bdc06a725c71235ULL, 0xc19bf174cf692694ULL,
+             0xe49b69c19ef14ad2ULL, 0xefbe4786384f25e3ULL,
+             0x0fc19dc68b8cd5b5ULL, 0x240ca1cc77ac9c65ULL,
+             0x2de92c6f592b0275ULL, 0x4a7484aa6ea6e483ULL,
+             0x5cb0a9dcbd41fbd4ULL, 0x76f988da831153b5ULL,
+             0x983e5152ee66dfabULL, 0xa831c66d2db43210ULL,
+             0xb00327c898fb213fULL, 0xbf597fc7beef0ee4ULL,
+             0xc6e00bf33da88fc2ULL, 0xd5a79147930aa725ULL,
+             0x06ca6351e003826fULL, 0x142929670a0e6e70ULL,
+             0x27b70a8546d22ffcULL, 0x2e1b21385c26c926ULL,
+             0x4d2c6dfc5ac42aedULL, 0x53380d139d95b3dfULL,
+             0x650a73548baf63deULL, 0x766a0abb3c77b2a8ULL,
+             0x81c2c92e47edaee6ULL, 0x92722c851482353bULL,
+             0xa2bfe8a14cf10364ULL, 0xa81a664bbc423001ULL,
+             0xc24b8b70d0f89791ULL, 0xc76c51a30654be30ULL,
+             0xd192e819d6ef5218ULL, 0xd69906245565a910ULL,
+             0xf40e35855771202aULL, 0x106aa07032bbd1b8ULL,
+             0x19a4c116b8d2d0c8ULL, 0x1e376c085141ab53ULL,
+             0x2748774cdf8eeb99ULL, 0x34b0bcb5e19b48a8ULL,
+             0x391c0cb3c5c95a63ULL, 0x4ed8aa4ae3418acbULL,
+             0x5b9cca4f7763e373ULL, 0x682e6ff3d6b2b8a3ULL,
+             0x748f82ee5defb2fcULL, 0x78a5636f43172f60ULL,
+             0x84c87814a1f0ab72ULL, 0x8cc702081a6439ecULL,
+             0x90befffa23631e28ULL, 0xa4506cebde82bde9ULL,
+             0xbef9a3f7b2c67915ULL, 0xc67178f2e372532bULL,
+             0xca273eceea26619cULL, 0xd186b8c721c0c207ULL,
+             0xeada7dd6cde0eb1eULL, 0xf57d4f7fee6ed178ULL,
+             0x06f067aa72176fbaULL, 0x0a637dc5a2c898a6ULL,
+             0x113f9804bef90daeULL, 0x1b710b35131c471bULL,
+             0x28db77f523047d84ULL, 0x32caab7b40c72493ULL,
+             0x3c9ebe0a15c9bebcULL, 0x431d67c49c100d4cULL,
+             0x4cc5d4becb3e42b6ULL, 0x597f299cfc657e2aULL,
+             0x5fcb6fab3ad6faecULL, 0x6c44198c4a475817ULL};
+ 
+void SHA512::transform(const unsigned char *message, unsigned int block_nb)
+{
+    uint64 w[80];
+    uint64 wv[8];
+    uint64 t1, t2;
+    const unsigned char *sub_block;
+    int i, j;
+    for (i = 0; i < (int) block_nb; i++) {
+        sub_block = message + (i << 7);
+        for (j = 0; j < 16; j++) {
+            SHA2_PACK64(&sub_block[j << 3], &w[j]);
+        }
+        for (j = 16; j < 80; j++) {
+            w[j] =  SHA512_F4(w[j -  2]) + w[j -  7] + SHA512_F3(w[j - 15]) + w[j - 16];
+        }
+        for (j = 0; j < 8; j++) {
+            wv[j] = m_h[j];
+        }
+        for (j = 0; j < 80; j++) {
+            t1 = wv[7] + SHA512_F2(wv[4]) + SHA2_CH(wv[4], wv[5], wv[6])
+                + sha512_k[j] + w[j];
+            t2 = SHA512_F1(wv[0]) + SHA2_MAJ(wv[0], wv[1], wv[2]);
+            wv[7] = wv[6];
+            wv[6] = wv[5];
+            wv[5] = wv[4];
+            wv[4] = wv[3] + t1;
+            wv[3] = wv[2];
+            wv[2] = wv[1];
+            wv[1] = wv[0];
+            wv[0] = t1 + t2;
+        }
+        for (j = 0; j < 8; j++) {
+            m_h[j] += wv[j];
+        }
+ 
+    }
+}
+ 
+void SHA512::init()
+{
+    m_h[0] = 0x6a09e667f3bcc908ULL;
+    m_h[1] = 0xbb67ae8584caa73bULL;
+    m_h[2] = 0x3c6ef372fe94f82bULL;
+    m_h[3] = 0xa54ff53a5f1d36f1ULL;
+    m_h[4] = 0x510e527fade682d1ULL;
+    m_h[5] = 0x9b05688c2b3e6c1fULL;
+    m_h[6] = 0x1f83d9abfb41bd6bULL; 
+    m_h[7] = 0x5be0cd19137e2179ULL;
+    m_len = 0;
+    m_tot_len = 0;
+}
+ 
+void SHA512::update(const unsigned char *message, unsigned int len)
+{
+    unsigned int block_nb;
+    unsigned int new_len, rem_len, tmp_len;
+    const unsigned char *shifted_message;
+    tmp_len = SHA384_512_BLOCK_SIZE - m_len;
+    rem_len = len < tmp_len ? len : tmp_len;
+    memcpy(&m_block[m_len], message, rem_len);
+    if (m_len + len < SHA384_512_BLOCK_SIZE) {
+        m_len += len;
+        return;
+    }
+    new_len = len - rem_len;
+    block_nb = new_len / SHA384_512_BLOCK_SIZE;
+    shifted_message = message + rem_len;
+    transform(m_block, 1);
+    transform(shifted_message, block_nb);
+    rem_len = new_len % SHA384_512_BLOCK_SIZE;
+    memcpy(m_block, &shifted_message[block_nb << 7], rem_len);
+    m_len = rem_len;
+    m_tot_len += (block_nb + 1) << 7;
+}
+ 
+void SHA512::final(unsigned char *digest)
+{
+    unsigned int block_nb;
+    unsigned int pm_len;
+    unsigned int len_b;
+    int i;
+    block_nb = 1 + ((SHA384_512_BLOCK_SIZE - 17)
+                     < (m_len % SHA384_512_BLOCK_SIZE));
+    len_b = (m_tot_len + m_len) << 3;
+    pm_len = block_nb << 7;
+    memset(m_block + m_len, 0, pm_len - m_len);
+    m_block[m_len] = 0x80;
+    SHA2_UNPACK32(len_b, m_block + pm_len - 4);
+    transform(m_block, block_nb);
+    for (i = 0 ; i < 8; i++) {
+        SHA2_UNPACK64(m_h[i], &digest[i << 3]);
+    }
+}
+ 
+std::string sha512(std::string input)
+{
+    unsigned char digest[SHA512::DIGEST_SIZE];
+    memset(digest,0,SHA512::DIGEST_SIZE);
+    SHA512 ctx = SHA512();
+    ctx.init();
+    ctx.update((unsigned char*)input.c_str(), input.length());
+    ctx.final(digest);
+ 
+    char buf[2*SHA512::DIGEST_SIZE+1];
+    buf[2*SHA512::DIGEST_SIZE] = 0;
+    for (int i = 0; i < SHA512::DIGEST_SIZE; i++)
+        sprintf(buf+i*2, "%02x", digest[i]);
+    return std::string(buf);
+}
diff --git a/source/sha512.h b/source/sha512.h
new file mode 100644
index 0000000..06c3606
--- /dev/null
+++ b/source/sha512.h
@@ -0,0 +1,71 @@
+#ifndef SHA512_H
+#define SHA512_H
+#include <string>
+ 
+class SHA512
+{
+protected:
+    typedef unsigned char uint8;
+    typedef unsigned int uint32;
+    typedef unsigned long long uint64;
+ 
+    const static uint64 sha512_k[];
+    static const unsigned int SHA384_512_BLOCK_SIZE = (1024/8);
+ 
+public:
+    void init();
+    void update(const unsigned char *message, unsigned int len);
+    void final(unsigned char *digest);
+    static const unsigned int DIGEST_SIZE = ( 512 / 8);
+ 
+protected:
+    void transform(const unsigned char *message, unsigned int block_nb);
+    unsigned int m_tot_len;
+    unsigned int m_len;
+    unsigned char m_block[2 * SHA384_512_BLOCK_SIZE];
+    uint64 m_h[8];
+};
+ 
+ 
+std::string sha512(std::string input);
+ 
+#define SHA2_SHFR(x, n)    (x >> n)
+#define SHA2_ROTR(x, n)   ((x >> n) | (x << ((sizeof(x) << 3) - n)))
+#define SHA2_ROTL(x, n)   ((x << n) | (x >> ((sizeof(x) << 3) - n)))
+#define SHA2_CH(x, y, z)  ((x & y) ^ (~x & z))
+#define SHA2_MAJ(x, y, z) ((x & y) ^ (x & z) ^ (y & z))
+#define SHA512_F1(x) (SHA2_ROTR(x, 28) ^ SHA2_ROTR(x, 34) ^ SHA2_ROTR(x, 39))
+#define SHA512_F2(x) (SHA2_ROTR(x, 14) ^ SHA2_ROTR(x, 18) ^ SHA2_ROTR(x, 41))
+#define SHA512_F3(x) (SHA2_ROTR(x,  1) ^ SHA2_ROTR(x,  8) ^ SHA2_SHFR(x,  7))
+#define SHA512_F4(x) (SHA2_ROTR(x, 19) ^ SHA2_ROTR(x, 61) ^ SHA2_SHFR(x,  6))
+#define SHA2_UNPACK32(x, str)                 \
+{                                             \
+    *((str) + 3) = (uint8) ((x)      );       \
+    *((str) + 2) = (uint8) ((x) >>  8);       \
+    *((str) + 1) = (uint8) ((x) >> 16);       \
+    *((str) + 0) = (uint8) ((x) >> 24);       \
+}
+#define SHA2_UNPACK64(x, str)                 \
+{                                             \
+    *((str) + 7) = (uint8) ((x)      );       \
+    *((str) + 6) = (uint8) ((x) >>  8);       \
+    *((str) + 5) = (uint8) ((x) >> 16);       \
+    *((str) + 4) = (uint8) ((x) >> 24);       \
+    *((str) + 3) = (uint8) ((x) >> 32);       \
+    *((str) + 2) = (uint8) ((x) >> 40);       \
+    *((str) + 1) = (uint8) ((x) >> 48);       \
+    *((str) + 0) = (uint8) ((x) >> 56);       \
+}
+#define SHA2_PACK64(str, x)                   \
+{                                             \
+    *(x) =   ((uint64) *((str) + 7)      )    \
+           | ((uint64) *((str) + 6) <<  8)    \
+           | ((uint64) *((str) + 5) << 16)    \
+           | ((uint64) *((str) + 4) << 24)    \
+           | ((uint64) *((str) + 3) << 32)    \
+           | ((uint64) *((str) + 2) << 40)    \
+           | ((uint64) *((str) + 1) << 48)    \
+           | ((uint64) *((str) + 0) << 56);   \
+}
+ 
+#endif
diff --git a/uninstall b/uninstall
new file mode 100755
index 0000000..257f044
--- /dev/null
+++ b/uninstall
@@ -0,0 +1,12 @@
+#!/bin/bash
+if [ ! -f /usr/bin/xlock ]; then
+	echo "xLock is not currently installed."
+	exit
+fi
+read -p "Are you shure you want to uninstall xLock? (Enter 'yes' or 'no'): " confirm
+if [ $confirm = "yes" ]; then
+	xlock
+	sudo rm /usr/bin/xlock -f 
+	rm ~/.xlockpw
+	echo -e "\e[93mxLock was successfully uninstalled\e[0m"
+fi