2012-08-02 15:54:18 -04:00
|
|
|
|
2008-04-08 04:55:46 -04:00
|
|
|
/* See LICENSE file for license details. */
|
2006-10-12 03:33:38 -04:00
|
|
|
#define _XOPEN_SOURCE 500
|
2006-10-31 02:43:25 -05:00
|
|
|
#if HAVE_SHADOW_H
|
|
|
|
#include <shadow.h>
|
|
|
|
#endif
|
2006-10-12 02:11:08 -04:00
|
|
|
|
2006-10-12 03:33:38 -04:00
|
|
|
#include <ctype.h>
|
2009-11-26 07:53:26 -05:00
|
|
|
#include <errno.h>
|
2006-10-31 02:35:54 -05:00
|
|
|
#include <pwd.h>
|
2007-11-24 15:17:32 -05:00
|
|
|
#include <stdarg.h>
|
2006-10-11 06:35:21 -04:00
|
|
|
#include <stdlib.h>
|
2014-07-17 17:03:00 -04:00
|
|
|
#define _GNU_SOURCE
|
2006-10-11 06:35:21 -04:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <sys/types.h>
|
2014-08-05 22:07:20 -04:00
|
|
|
#include <sys/stat.h>
|
2006-10-11 06:35:21 -04:00
|
|
|
#include <X11/keysym.h>
|
|
|
|
#include <X11/Xlib.h>
|
|
|
|
#include <X11/Xutil.h>
|
2015-10-27 15:56:45 -04:00
|
|
|
#include <X11/extensions/dpms.h>
|
2015-01-26 20:21:29 -05:00
|
|
|
#include <X11/Xatom.h>
|
2008-02-22 05:13:12 -05:00
|
|
|
|
|
|
|
#if HAVE_BSD_AUTH
|
|
|
|
#include <login_cap.h>
|
|
|
|
#include <bsd_auth.h>
|
|
|
|
#endif
|
2006-10-11 06:35:21 -04:00
|
|
|
|
2014-08-26 03:21:28 -04:00
|
|
|
#define CMD_LENGTH (500 * sizeof(char))
|
|
|
|
|
2015-10-27 15:56:45 -04:00
|
|
|
#define POWEROFF 0
|
|
|
|
#define TWILIO_SEND 0
|
|
|
|
#define WEBCAM_SHOT 0
|
2014-08-26 03:21:28 -04:00
|
|
|
#define IMGUR_UPLOAD 0
|
2015-10-27 15:56:45 -04:00
|
|
|
#define PLAY_AUDIO 0
|
|
|
|
#define TRANSPARENT 0
|
2014-08-19 23:10:34 -04:00
|
|
|
|
2015-10-27 15:56:45 -04:00
|
|
|
#if IMGUR_UPLOAD
|
2014-08-26 03:21:28 -04:00
|
|
|
#include "imgur.h"
|
2015-10-27 15:56:45 -04:00
|
|
|
#endif
|
|
|
|
#if TWILIO_SEND
|
2014-08-19 23:10:34 -04:00
|
|
|
#include "twilio.h"
|
2015-10-27 15:56:45 -04:00
|
|
|
#endif
|
2014-08-26 03:21:28 -04:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
char *link;
|
|
|
|
char *deletehash;
|
|
|
|
} imgur_data;
|
2014-07-22 12:29:05 -04:00
|
|
|
|
2014-07-15 20:10:29 -04:00
|
|
|
char *g_pw = NULL;
|
2014-07-16 17:54:53 -04:00
|
|
|
int lock_tries = 0;
|
2014-07-15 20:10:29 -04:00
|
|
|
|
2012-02-05 10:38:58 -05:00
|
|
|
typedef struct {
|
2009-11-26 07:53:26 -05:00
|
|
|
int screen;
|
2012-02-05 10:38:58 -05:00
|
|
|
Window root, win;
|
2009-11-26 07:53:26 -05:00
|
|
|
Pixmap pmap;
|
2012-03-17 13:03:25 -04:00
|
|
|
unsigned long colors[2];
|
2012-02-05 10:38:58 -05:00
|
|
|
} Lock;
|
2009-11-26 07:53:26 -05:00
|
|
|
|
2012-02-05 10:38:58 -05:00
|
|
|
static Lock **locks;
|
|
|
|
static int nscreens;
|
|
|
|
static Bool running = True;
|
2009-11-26 07:53:26 -05:00
|
|
|
|
2008-07-29 14:14:53 -04:00
|
|
|
static void
|
2008-07-29 14:08:18 -04:00
|
|
|
die(const char *errstr, ...) {
|
2007-11-24 15:17:32 -05:00
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, errstr);
|
|
|
|
vfprintf(stderr, errstr, ap);
|
|
|
|
va_end(ap);
|
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
2013-08-02 16:11:18 -04:00
|
|
|
#ifdef __linux__
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
|
|
|
static void
|
|
|
|
dontkillme(void) {
|
|
|
|
int fd;
|
|
|
|
|
|
|
|
fd = open("/proc/self/oom_score_adj", O_WRONLY);
|
|
|
|
if (fd < 0 && errno == ENOENT)
|
|
|
|
return;
|
|
|
|
if (fd < 0 || write(fd, "-1000\n", 6) != 6 || close(fd) != 0)
|
2014-07-15 20:10:29 -04:00
|
|
|
fprintf(stderr, "cannot disable the out-of-memory killer for this process\n");
|
2013-08-02 16:11:18 -04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2008-02-22 05:13:12 -05:00
|
|
|
#ifndef HAVE_BSD_AUTH
|
2014-07-15 20:10:29 -04:00
|
|
|
|
2008-07-29 14:14:53 -04:00
|
|
|
static const char *
|
2012-01-22 12:58:10 -05:00
|
|
|
getpw(void) { /* only run as root */
|
2006-10-31 02:35:54 -05:00
|
|
|
const char *rval;
|
|
|
|
struct passwd *pw;
|
|
|
|
|
2014-07-16 17:54:53 -04:00
|
|
|
if(g_pw)
|
2014-07-15 20:10:29 -04:00
|
|
|
return g_pw;
|
|
|
|
|
2013-11-14 06:24:08 -05:00
|
|
|
errno = 0;
|
2006-10-31 02:35:54 -05:00
|
|
|
pw = getpwuid(getuid());
|
2014-07-09 09:40:49 -04:00
|
|
|
if (!pw) {
|
|
|
|
if (errno)
|
|
|
|
die("slock: getpwuid: %s\n", strerror(errno));
|
|
|
|
else
|
|
|
|
die("slock: cannot retrieve password entry (make sure to suid or sgid slock)\n");
|
|
|
|
}
|
2006-10-31 02:35:54 -05:00
|
|
|
endpwent();
|
|
|
|
rval = pw->pw_passwd;
|
|
|
|
|
|
|
|
#if HAVE_SHADOW_H
|
2014-06-03 13:19:10 -04:00
|
|
|
if (rval[0] == 'x' && rval[1] == '\0') {
|
2006-10-31 02:35:54 -05:00
|
|
|
struct spwd *sp;
|
|
|
|
sp = getspnam(getenv("USER"));
|
2012-01-24 16:10:02 -05:00
|
|
|
if(!sp)
|
|
|
|
die("slock: cannot retrieve shadow entry (make sure to suid or sgid slock)\n");
|
2006-10-31 02:35:54 -05:00
|
|
|
endspent();
|
|
|
|
rval = sp->sp_pwdp;
|
|
|
|
}
|
|
|
|
#endif
|
2008-02-22 05:13:12 -05:00
|
|
|
|
2006-10-31 02:35:54 -05:00
|
|
|
/* drop privileges */
|
2013-08-02 16:11:18 -04:00
|
|
|
if (geteuid() == 0
|
|
|
|
&& ((getegid() != pw->pw_gid && setgid(pw->pw_gid) < 0) || setuid(pw->pw_uid) < 0))
|
|
|
|
die("slock: cannot drop privileges\n");
|
2006-10-31 02:35:54 -05:00
|
|
|
return rval;
|
|
|
|
}
|
2008-02-22 05:13:12 -05:00
|
|
|
#endif
|
2006-10-31 02:35:54 -05:00
|
|
|
|
2014-08-26 03:21:28 -04:00
|
|
|
static char *
|
|
|
|
read_tfile(char *name) {
|
|
|
|
FILE *f = fopen(name, "r");
|
|
|
|
|
|
|
|
struct stat s;
|
|
|
|
if (stat(name, &s) == -1) goto error;
|
|
|
|
|
|
|
|
char *buf = malloc(s.st_size);
|
|
|
|
if (buf == NULL) goto error;
|
|
|
|
fread(buf, 1, s.st_size, f);
|
|
|
|
fclose(f);
|
|
|
|
|
|
|
|
int i = 0;
|
|
|
|
while (buf[i]) {
|
|
|
|
if (buf[i] == '\r' || buf[i] == '\n') {
|
|
|
|
buf[i] = '\0';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf;
|
|
|
|
|
|
|
|
error:
|
|
|
|
fprintf(stderr, "Could not open: %s.\n", name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-09-19 05:15:38 -04:00
|
|
|
// Disable alt+sysrq and crtl+alt+backspace - keeps the
|
|
|
|
// attacker from alt+sysrq+k'ing our process
|
2014-09-18 17:38:54 -04:00
|
|
|
static void
|
2014-09-19 05:15:38 -04:00
|
|
|
disable_kill(void) {
|
2014-09-18 17:38:54 -04:00
|
|
|
#if POWEROFF
|
|
|
|
// Needs sudo privileges - alter your /etc/sudoers file:
|
|
|
|
// [username] [hostname] =NOPASSWD: /usr/bin/tee /proc/sys/kernel/sysrq
|
2014-09-18 21:19:47 -04:00
|
|
|
system("echo 0 | sudo tee /proc/sys/kernel/sysrq > /dev/null &");
|
|
|
|
// Disable ctrl+alt+backspace
|
|
|
|
system("setxkbmap -option &");
|
2014-09-18 17:38:54 -04:00
|
|
|
#else
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2014-08-26 03:21:28 -04:00
|
|
|
// Poweroff if we're in danger.
|
2014-08-19 23:10:34 -04:00
|
|
|
static void
|
2014-08-26 03:21:28 -04:00
|
|
|
poweroff(void) {
|
|
|
|
#if POWEROFF
|
2014-08-19 23:10:34 -04:00
|
|
|
// Needs sudo privileges - alter your /etc/sudoers file:
|
|
|
|
// systemd: [username] [hostname] =NOPASSWD: /usr/bin/systemctl poweroff
|
|
|
|
// sysvinit: [username] [hostname] =NOPASSWD: /usr/bin/shutdown -h now
|
2015-10-27 15:56:45 -04:00
|
|
|
char *args[] = { "sudo", "shutdown", "-h", "now", NULL };
|
2014-08-26 03:21:28 -04:00
|
|
|
execvp(args[0], args);
|
2014-08-19 23:10:34 -04:00
|
|
|
fprintf(stderr, "Error: cannot shutdown. Check your /etc/sudoers file.\n");
|
2014-09-18 17:38:54 -04:00
|
|
|
// Needs sudo privileges - alter your /etc/sudoers file:
|
|
|
|
// [username] [hostname] =NOPASSWD: /usr/bin/tee /proc/sys/kernel/sysrq,/usr/bin/tee /proc/sysrq-trigger
|
|
|
|
// system("echo 1 | sudo tee /proc/sys/kernel/sysrq > /dev/null");
|
|
|
|
// system("echo o | sudo tee /proc/sysrq-trigger > /dev/null");
|
2014-08-26 03:21:28 -04:00
|
|
|
#else
|
|
|
|
return;
|
|
|
|
#endif
|
2014-08-19 23:10:34 -04:00
|
|
|
}
|
2014-08-26 03:21:28 -04:00
|
|
|
|
|
|
|
// Take a screenshot of whoever is at the keyboard.
|
|
|
|
static int
|
|
|
|
webcam_shot(int async) {
|
|
|
|
#if WEBCAM_SHOT
|
|
|
|
char *cmd = (char *)malloc(CMD_LENGTH);
|
|
|
|
|
|
|
|
int r = snprintf(cmd, CMD_LENGTH,
|
|
|
|
"ffmpeg -y -loglevel quiet -f video4linux2 -i /dev/video0"
|
|
|
|
" -frames:v 1 -f image2 %s/slock.jpg%s",
|
|
|
|
getenv("HOME"), async ? " &" : "");
|
|
|
|
|
|
|
|
if (r > 0) {
|
|
|
|
system(cmd);
|
|
|
|
r = 0;
|
|
|
|
} else {
|
|
|
|
r = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(cmd);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
twilio_send(const char *msg, imgur_data *idata, int async) {
|
|
|
|
#if TWILIO_SEND
|
|
|
|
char *cmd = (char *)malloc(CMD_LENGTH);
|
|
|
|
|
|
|
|
// Send the SMS/MMS via Twilio
|
|
|
|
int r = snprintf(cmd, CMD_LENGTH,
|
|
|
|
"curl -s -A '' -X POST https://api.twilio.com/2010-04-01/Accounts/"
|
|
|
|
TWILIO_ACCOUNT "/SMS/Messages.json"
|
|
|
|
" -u " TWILIO_AUTH
|
|
|
|
" --data-urlencode 'From=" TWILIO_FROM "'"
|
|
|
|
" --data-urlencode 'To=" TWILIO_TO "'"
|
|
|
|
" --data-urlencode 'Body=%s'"
|
|
|
|
" --data-urlencode 'MediaUrl=%s' > /dev/null"
|
|
|
|
"%s", msg, idata ? idata->link : "", async ? " &" : "");
|
|
|
|
|
|
|
|
if (r > 0) {
|
|
|
|
system(cmd);
|
|
|
|
r = 0;
|
|
|
|
} else {
|
|
|
|
r = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(cmd);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static imgur_data *
|
|
|
|
imgur_upload(void) {
|
|
|
|
#if IMGUR_UPLOAD
|
|
|
|
char *buf = (char *)malloc(CMD_LENGTH);
|
|
|
|
imgur_data *idata = (imgur_data *)malloc(sizeof(imgur_data));
|
|
|
|
memset(idata, 0, sizeof(imgur_data));
|
|
|
|
int r;
|
|
|
|
|
|
|
|
// Upload the imgur image:
|
|
|
|
r = snprintf(buf, CMD_LENGTH,
|
|
|
|
"curl -s -A '' -X POST"
|
|
|
|
" -H 'Authorization: Client-ID " IMGUR_CLIENT "'"
|
|
|
|
" -F 'image=@%s/slock.jpg'"
|
|
|
|
" 'https://api.imgur.com/3/image' > %s/slock_imgur.curl",
|
|
|
|
getenv("HOME"), getenv("HOME"));
|
|
|
|
|
|
|
|
if (r > 0) {
|
|
|
|
system(buf);
|
|
|
|
r = 0;
|
|
|
|
} else {
|
|
|
|
r = -1;
|
|
|
|
}
|
|
|
|
if (r == -1) return NULL;
|
|
|
|
|
|
|
|
// Get the link:
|
|
|
|
r = snprintf(buf, CMD_LENGTH,
|
|
|
|
"cat %s/slock_imgur.curl"
|
|
|
|
" | grep -o '\"link\":\"[^\"]\\+'"
|
|
|
|
" | sed 's/\\\\//g'"
|
|
|
|
" | grep -o '[^\"]\\+$'"
|
|
|
|
" > %s/slock_imgur.link",
|
|
|
|
getenv("HOME"), getenv("HOME"));
|
|
|
|
|
|
|
|
if (r > 0) {
|
|
|
|
system(buf);
|
|
|
|
r = 0;
|
|
|
|
} else {
|
|
|
|
r = -1;
|
|
|
|
}
|
|
|
|
if (r == -1) return NULL;
|
|
|
|
|
|
|
|
// Get the deletehash:
|
|
|
|
r = snprintf(buf, CMD_LENGTH,
|
|
|
|
"cat %s/slock_imgur.curl"
|
|
|
|
" | grep -o '\"deletehash\":\"[^\"]\\+'"
|
|
|
|
" | grep -o '[^\"]\\+$'"
|
|
|
|
" > %s/slock_imgur.deletehash",
|
|
|
|
getenv("HOME"), getenv("HOME"));
|
|
|
|
|
|
|
|
if (r > 0) {
|
|
|
|
system(buf);
|
|
|
|
r = 0;
|
|
|
|
} else {
|
|
|
|
r = -1;
|
|
|
|
}
|
|
|
|
if (r == -1) return NULL;
|
|
|
|
|
|
|
|
r = snprintf(buf, CMD_LENGTH, "%s/slock_imgur.curl", getenv("HOME"));
|
|
|
|
if (r > 0) {
|
|
|
|
unlink(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
r = snprintf(buf, CMD_LENGTH, "%s/slock_imgur.link", getenv("HOME"));
|
|
|
|
if (r > 0) {
|
|
|
|
idata->link = read_tfile(buf);
|
|
|
|
unlink(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
r = snprintf(buf, CMD_LENGTH, "%s/slock_imgur.deletehash", getenv("HOME"));
|
|
|
|
if (r > 0) {
|
|
|
|
idata->deletehash = read_tfile(buf);
|
|
|
|
unlink(buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(buf);
|
|
|
|
|
|
|
|
if (idata->link == NULL
|
|
|
|
|| !strlen(idata->link)
|
|
|
|
|| idata->deletehash == NULL
|
|
|
|
|| !strlen(idata->deletehash)) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return idata;
|
|
|
|
#else
|
|
|
|
return NULL;
|
2014-08-19 23:10:34 -04:00
|
|
|
#endif
|
2014-08-26 03:21:28 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
imgur_delete(imgur_data *idata) {
|
|
|
|
#if IMGUR_UPLOAD
|
|
|
|
char *cmd = (char *)malloc(CMD_LENGTH);
|
|
|
|
|
|
|
|
// Delete the imgur image:
|
|
|
|
int r = snprintf(cmd, CMD_LENGTH,
|
|
|
|
"curl -s -A '' -X DELETE"
|
|
|
|
" -H 'Authorization: Client-ID " IMGUR_CLIENT "'"
|
|
|
|
" 'https://api.imgur.com/3/image/%s'", idata->deletehash);
|
|
|
|
|
|
|
|
// Wait for Twilio to do its request:
|
2014-09-19 05:22:30 -04:00
|
|
|
sleep(5);
|
2014-08-26 03:21:28 -04:00
|
|
|
|
|
|
|
if (r > 0) {
|
|
|
|
system(cmd);
|
|
|
|
r = 0;
|
|
|
|
} else {
|
|
|
|
r = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(cmd);
|
|
|
|
free(idata->link);
|
|
|
|
free(idata->deletehash);
|
|
|
|
free(idata);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
#else
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
play_beep(int async) {
|
|
|
|
#if PLAY_AUDIO
|
|
|
|
char snd[255] = {0};
|
|
|
|
snprintf(snd, sizeof(snd), "aplay %s/slock/beep.wav 2> /dev/null%s",
|
|
|
|
getenv("HOME"), async ? " &" : "");
|
|
|
|
system(snd);
|
|
|
|
#else
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
play_alarm(int async) {
|
|
|
|
#if PLAY_AUDIO
|
|
|
|
char snd[255] = {0};
|
|
|
|
snprintf(snd, sizeof(snd), "aplay %s/slock/police.wav 2> /dev/null%s",
|
|
|
|
getenv("HOME"), async ? " &" : "");
|
|
|
|
system(snd);
|
|
|
|
#else
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
}
|
2014-08-19 23:10:34 -04:00
|
|
|
|
2009-11-26 07:53:26 -05:00
|
|
|
static void
|
|
|
|
#ifdef HAVE_BSD_AUTH
|
2012-01-22 12:58:10 -05:00
|
|
|
readpw(Display *dpy)
|
2009-11-26 07:53:26 -05:00
|
|
|
#else
|
2012-01-22 12:58:10 -05:00
|
|
|
readpw(Display *dpy, const char *pws)
|
2009-11-26 07:53:26 -05:00
|
|
|
#endif
|
|
|
|
{
|
2006-10-11 06:35:21 -04:00
|
|
|
char buf[32], passwd[256];
|
2012-02-05 10:38:58 -05:00
|
|
|
int num, screen;
|
2015-01-26 20:21:29 -05:00
|
|
|
#if !TRANSPARENT
|
2012-03-17 13:03:25 -04:00
|
|
|
unsigned int len, llen;
|
2015-01-26 20:21:29 -05:00
|
|
|
#else
|
|
|
|
unsigned int len;
|
|
|
|
#endif
|
2006-10-11 11:04:04 -04:00
|
|
|
KeySym ksym;
|
2006-10-11 06:35:21 -04:00
|
|
|
XEvent ev;
|
2014-08-26 03:21:28 -04:00
|
|
|
imgur_data *idata = NULL;
|
2006-10-11 06:35:21 -04:00
|
|
|
|
2015-01-26 20:21:29 -05:00
|
|
|
#if !TRANSPARENT
|
2012-03-17 13:03:25 -04:00
|
|
|
len = llen = 0;
|
2015-01-26 20:21:29 -05:00
|
|
|
#else
|
|
|
|
len = 0;
|
|
|
|
#endif
|
2009-11-26 07:53:26 -05:00
|
|
|
running = True;
|
2006-10-11 07:33:04 -04:00
|
|
|
|
2009-11-26 07:53:26 -05:00
|
|
|
/* As "slock" stands for "Simple X display locker", the DPMS settings
|
|
|
|
* had been removed and you can set it with "xset" or some other
|
|
|
|
* utility. This way the user can easily set a customized DPMS
|
|
|
|
* timeout. */
|
2008-02-22 05:13:12 -05:00
|
|
|
while(running && !XNextEvent(dpy, &ev)) {
|
2015-10-27 15:56:45 -04:00
|
|
|
if(len == 0 && DPMSCapable(dpy)) {
|
|
|
|
DPMSEnable(dpy);
|
|
|
|
DPMSForceLevel(dpy, DPMSModeOff);
|
|
|
|
}
|
2006-10-11 06:35:21 -04:00
|
|
|
if(ev.type == KeyPress) {
|
|
|
|
buf[0] = 0;
|
2006-11-26 09:50:18 -05:00
|
|
|
num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0);
|
2008-07-29 14:14:53 -04:00
|
|
|
if(IsKeypadKey(ksym)) {
|
2008-04-08 04:55:46 -04:00
|
|
|
if(ksym == XK_KP_Enter)
|
|
|
|
ksym = XK_Return;
|
|
|
|
else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
|
|
|
|
ksym = (ksym - XK_KP_0) + XK_0;
|
2008-07-29 14:14:53 -04:00
|
|
|
}
|
2006-10-11 06:35:21 -04:00
|
|
|
if(IsFunctionKey(ksym) || IsKeypadKey(ksym)
|
|
|
|
|| IsMiscFunctionKey(ksym) || IsPFKey(ksym)
|
|
|
|
|| IsPrivateKeypadKey(ksym))
|
|
|
|
continue;
|
|
|
|
switch(ksym) {
|
|
|
|
case XK_Return:
|
2006-10-31 02:35:54 -05:00
|
|
|
passwd[len] = 0;
|
2014-07-16 17:54:53 -04:00
|
|
|
if(g_pw) {
|
2014-07-15 20:10:29 -04:00
|
|
|
running = !!strcmp(passwd, g_pw);
|
|
|
|
} else {
|
2014-09-30 15:22:12 -04:00
|
|
|
#ifdef HAVE_BSD_AUTH
|
|
|
|
running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd);
|
|
|
|
#else
|
2014-07-15 20:10:29 -04:00
|
|
|
running = !!strcmp(crypt(passwd, pws), pws);
|
2008-02-22 05:13:12 -05:00
|
|
|
#endif
|
2014-09-30 15:22:12 -04:00
|
|
|
}
|
2014-07-16 17:54:53 -04:00
|
|
|
if(running) {
|
2006-10-11 07:33:04 -04:00
|
|
|
XBell(dpy, 100);
|
2014-07-22 12:29:05 -04:00
|
|
|
lock_tries++;
|
2014-08-26 03:21:28 -04:00
|
|
|
|
|
|
|
// Poweroff if there are more than 5 bad attempts.
|
2014-07-22 12:29:05 -04:00
|
|
|
if(lock_tries > 5) {
|
2014-09-19 05:15:38 -04:00
|
|
|
// Disable alt+sysrq and crtl+alt+backspace
|
|
|
|
disable_kill();
|
2014-09-18 17:38:54 -04:00
|
|
|
|
2014-08-26 03:21:28 -04:00
|
|
|
// Take a webcam shot of whoever is tampering with our machine:
|
|
|
|
webcam_shot(0);
|
|
|
|
|
|
|
|
// Upload the image:
|
|
|
|
idata = imgur_upload();
|
|
|
|
|
|
|
|
// Send an SMS/MMS via twilio:
|
|
|
|
twilio_send("Bad screenlock password.", idata, 0);
|
|
|
|
|
|
|
|
// Delete the image from imgur:
|
|
|
|
imgur_delete(idata);
|
|
|
|
|
|
|
|
// Immediately poweroff:
|
2014-08-19 23:10:34 -04:00
|
|
|
poweroff();
|
2014-08-26 03:21:28 -04:00
|
|
|
|
|
|
|
// If we failed, simply resume:
|
2014-07-22 12:29:05 -04:00
|
|
|
len = 0;
|
|
|
|
break;
|
2014-08-26 03:21:28 -04:00
|
|
|
} else {
|
|
|
|
// Take a webcam shot of whoever is tampering with our machine:
|
|
|
|
webcam_shot(1);
|
|
|
|
|
|
|
|
// Send an SMS via twilio:
|
|
|
|
twilio_send("Bad screenlock password.", NULL, 1);
|
2014-07-22 12:29:05 -04:00
|
|
|
}
|
2014-08-26 03:21:28 -04:00
|
|
|
|
|
|
|
// Play a siren if there are more than 2 bad
|
|
|
|
// passwords, a beep if a correct password:
|
2014-07-22 12:29:05 -04:00
|
|
|
if(lock_tries > 2) {
|
2014-08-26 03:21:28 -04:00
|
|
|
play_alarm(0);
|
2014-07-17 17:03:00 -04:00
|
|
|
} else {
|
2014-08-26 03:21:28 -04:00
|
|
|
play_beep(0);
|
2014-07-16 17:54:53 -04:00
|
|
|
}
|
2015-01-26 22:24:38 -05:00
|
|
|
#if 0
|
2014-07-17 17:03:00 -04:00
|
|
|
} else {
|
2014-08-26 03:21:28 -04:00
|
|
|
play_beep(1);
|
2015-01-26 22:24:38 -05:00
|
|
|
#endif
|
2014-07-16 17:54:53 -04:00
|
|
|
}
|
2006-10-31 02:35:54 -05:00
|
|
|
len = 0;
|
2006-10-11 06:35:21 -04:00
|
|
|
break;
|
|
|
|
case XK_Escape:
|
2006-10-31 02:35:54 -05:00
|
|
|
len = 0;
|
2006-10-11 06:35:21 -04:00
|
|
|
break;
|
2014-09-19 05:15:38 -04:00
|
|
|
case XK_Delete:
|
2014-09-19 13:59:44 -04:00
|
|
|
case XK_BackSpace:
|
2006-10-11 06:35:21 -04:00
|
|
|
if(len)
|
2006-10-31 02:43:25 -05:00
|
|
|
--len;
|
2006-10-11 06:35:21 -04:00
|
|
|
break;
|
2014-07-30 16:02:56 -04:00
|
|
|
case XK_Alt_L:
|
|
|
|
case XK_Alt_R:
|
|
|
|
case XK_Control_L:
|
|
|
|
case XK_Control_R:
|
2015-01-31 05:04:49 -05:00
|
|
|
case XK_Meta_L:
|
|
|
|
case XK_Meta_R:
|
|
|
|
case XK_Super_L:
|
|
|
|
case XK_Super_R:
|
2014-07-30 16:02:56 -04:00
|
|
|
case XK_F1:
|
|
|
|
case XK_F2:
|
|
|
|
case XK_F3:
|
|
|
|
case XK_F4:
|
|
|
|
case XK_F5:
|
|
|
|
case XK_F6:
|
2014-08-06 13:16:33 -04:00
|
|
|
case XK_F7:
|
|
|
|
case XK_F8:
|
|
|
|
case XK_F9:
|
|
|
|
case XK_F10:
|
|
|
|
case XK_F11:
|
|
|
|
case XK_F12:
|
2014-08-10 21:35:52 -04:00
|
|
|
case XK_F13:
|
2014-09-19 13:59:44 -04:00
|
|
|
// case XK_BackSpace:
|
2014-09-19 05:15:38 -04:00
|
|
|
// Disable alt+sysrq and crtl+alt+backspace
|
|
|
|
disable_kill();
|
2014-09-18 17:38:54 -04:00
|
|
|
|
2014-08-26 03:21:28 -04:00
|
|
|
// Take a webcam shot of whoever is tampering with our machine:
|
|
|
|
webcam_shot(0);
|
|
|
|
|
|
|
|
// Upload our image:
|
|
|
|
idata = imgur_upload();
|
|
|
|
|
|
|
|
// Send an SMS/MMS via twilio:
|
|
|
|
twilio_send("Bad screenlock key.", idata, 0);
|
|
|
|
|
|
|
|
// Delete the image from imgur:
|
|
|
|
imgur_delete(idata);
|
|
|
|
|
|
|
|
// Immediately poweroff:
|
2014-08-19 23:10:34 -04:00
|
|
|
poweroff();
|
2014-08-26 03:21:28 -04:00
|
|
|
|
2014-08-19 23:10:34 -04:00
|
|
|
; // fall-through if we fail
|
2006-10-11 06:35:21 -04:00
|
|
|
default:
|
2014-06-03 13:19:10 -04:00
|
|
|
if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) {
|
2006-10-31 02:43:25 -05:00
|
|
|
memcpy(passwd + len, buf, num);
|
2006-10-31 02:35:54 -05:00
|
|
|
len += num;
|
2006-10-11 06:35:21 -04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2015-01-26 20:21:29 -05:00
|
|
|
#if !TRANSPARENT
|
2012-03-17 13:03:25 -04:00
|
|
|
if(llen == 0 && len != 0) {
|
|
|
|
for(screen = 0; screen < nscreens; screen++) {
|
|
|
|
XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[1]);
|
|
|
|
XClearWindow(dpy, locks[screen]->win);
|
|
|
|
}
|
|
|
|
} else if(llen != 0 && len == 0) {
|
|
|
|
for(screen = 0; screen < nscreens; screen++) {
|
|
|
|
XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[0]);
|
|
|
|
XClearWindow(dpy, locks[screen]->win);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
llen = len;
|
2015-01-26 20:21:29 -05:00
|
|
|
#endif
|
2006-10-11 06:35:21 -04:00
|
|
|
}
|
2012-02-05 10:38:58 -05:00
|
|
|
else for(screen = 0; screen < nscreens; screen++)
|
2012-02-05 10:41:31 -05:00
|
|
|
XRaiseWindow(dpy, locks[screen]->win);
|
2008-02-22 05:13:12 -05:00
|
|
|
}
|
2009-11-26 07:53:26 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2012-02-05 10:38:58 -05:00
|
|
|
unlockscreen(Display *dpy, Lock *lock) {
|
|
|
|
if(dpy == NULL || lock == NULL)
|
2009-11-26 07:53:26 -05:00
|
|
|
return;
|
|
|
|
|
2006-10-16 06:59:37 -04:00
|
|
|
XUngrabPointer(dpy, CurrentTime);
|
2015-01-26 20:21:29 -05:00
|
|
|
#if !TRANSPARENT
|
2012-03-17 13:03:25 -04:00
|
|
|
XFreeColors(dpy, DefaultColormap(dpy, lock->screen), lock->colors, 2, 0);
|
2009-11-26 07:53:26 -05:00
|
|
|
XFreePixmap(dpy, lock->pmap);
|
2015-01-26 20:21:29 -05:00
|
|
|
#endif
|
2012-02-05 10:38:58 -05:00
|
|
|
XDestroyWindow(dpy, lock->win);
|
2009-11-26 07:53:26 -05:00
|
|
|
|
|
|
|
free(lock);
|
|
|
|
}
|
|
|
|
|
2012-02-05 10:38:58 -05:00
|
|
|
static Lock *
|
2009-11-26 07:53:26 -05:00
|
|
|
lockscreen(Display *dpy, int screen) {
|
2015-01-26 20:21:29 -05:00
|
|
|
#if !TRANSPARENT
|
2009-11-26 07:53:26 -05:00
|
|
|
char curs[] = {0, 0, 0, 0, 0, 0, 0, 0};
|
2015-01-26 20:21:29 -05:00
|
|
|
#endif
|
2009-11-26 07:53:26 -05:00
|
|
|
unsigned int len;
|
2012-02-05 10:38:58 -05:00
|
|
|
Lock *lock;
|
2015-01-26 20:21:29 -05:00
|
|
|
#if !TRANSPARENT
|
2012-03-17 13:03:25 -04:00
|
|
|
XColor color, dummy;
|
2015-01-26 20:21:29 -05:00
|
|
|
#endif
|
2009-11-26 07:53:26 -05:00
|
|
|
XSetWindowAttributes wa;
|
2015-01-26 20:21:29 -05:00
|
|
|
#if !TRANSPARENT
|
2009-11-26 07:53:26 -05:00
|
|
|
Cursor invisible;
|
2015-01-26 20:21:29 -05:00
|
|
|
#endif
|
|
|
|
#if TRANSPARENT
|
|
|
|
XVisualInfo vi;
|
|
|
|
#endif
|
2009-11-26 07:53:26 -05:00
|
|
|
|
2012-02-05 10:38:58 -05:00
|
|
|
if(dpy == NULL || screen < 0)
|
2009-11-26 07:53:26 -05:00
|
|
|
return NULL;
|
|
|
|
|
2012-02-05 10:38:58 -05:00
|
|
|
lock = malloc(sizeof(Lock));
|
|
|
|
if(lock == NULL)
|
2009-11-26 07:53:26 -05:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
lock->screen = screen;
|
|
|
|
|
|
|
|
lock->root = RootWindow(dpy, lock->screen);
|
|
|
|
|
2015-01-26 20:21:29 -05:00
|
|
|
#if TRANSPARENT
|
|
|
|
XMatchVisualInfo(dpy, DefaultScreen(dpy), 32, TrueColor, &vi);
|
|
|
|
wa.colormap = XCreateColormap(dpy, DefaultRootWindow(dpy), vi.visual, AllocNone);
|
|
|
|
#endif
|
|
|
|
|
2009-11-26 07:53:26 -05:00
|
|
|
/* init */
|
|
|
|
wa.override_redirect = 1;
|
2015-01-26 20:21:29 -05:00
|
|
|
#if !TRANSPARENT
|
2009-11-26 07:53:26 -05:00
|
|
|
wa.background_pixel = BlackPixel(dpy, lock->screen);
|
2015-01-26 20:21:29 -05:00
|
|
|
#else
|
|
|
|
wa.border_pixel = 0;
|
2015-01-31 05:04:49 -05:00
|
|
|
wa.background_pixel = 0xaa000000;
|
2015-01-26 20:21:29 -05:00
|
|
|
#endif
|
2012-02-05 10:38:58 -05:00
|
|
|
lock->win = XCreateWindow(dpy, lock->root, 0, 0, DisplayWidth(dpy, lock->screen), DisplayHeight(dpy, lock->screen),
|
2015-01-26 20:21:29 -05:00
|
|
|
#if !TRANSPARENT
|
2009-11-26 07:53:26 -05:00
|
|
|
0, DefaultDepth(dpy, lock->screen), CopyFromParent,
|
|
|
|
DefaultVisual(dpy, lock->screen), CWOverrideRedirect | CWBackPixel, &wa);
|
2015-01-26 20:21:29 -05:00
|
|
|
#else
|
|
|
|
0, vi.depth, CopyFromParent,
|
|
|
|
vi.visual, CWOverrideRedirect | CWBackPixel | CWColormap | CWBorderPixel, &wa);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
Atom name_atom = XA_WM_NAME;
|
2015-01-31 05:04:49 -05:00
|
|
|
XTextProperty name_prop = { "slock", name_atom, 8, 5 };
|
2015-01-26 20:21:29 -05:00
|
|
|
XSetWMName(dpy, lock->win, &name_prop);
|
2015-01-31 05:04:49 -05:00
|
|
|
|
|
|
|
// Atom name_ewmh_atom = XInternAtom(dpy, "_NET_WM_NAME", False);
|
|
|
|
// XTextProperty name_ewmh_prop = { "slock", name_ewmh_atom, 8, 5 };
|
|
|
|
// XSetTextProperty(dpy, lock->win, &name_ewmh_prop, name_ewmh_atom);
|
|
|
|
// XSetWMName(dpy, lock->win, &name_ewmh_prop);
|
|
|
|
|
|
|
|
XClassHint *hint = XAllocClassHint();
|
|
|
|
if (hint) {
|
|
|
|
hint->res_name = "slock";
|
|
|
|
hint->res_class = "slock";
|
|
|
|
XSetClassHint(dpy, lock->win, hint);
|
|
|
|
XFree(hint);
|
|
|
|
}
|
2015-01-26 20:21:29 -05:00
|
|
|
|
|
|
|
#if !TRANSPARENT
|
2012-03-17 13:03:25 -04:00
|
|
|
XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen), COLOR2, &color, &dummy);
|
|
|
|
lock->colors[1] = color.pixel;
|
|
|
|
XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen), COLOR1, &color, &dummy);
|
|
|
|
lock->colors[0] = color.pixel;
|
2012-02-05 10:38:58 -05:00
|
|
|
lock->pmap = XCreateBitmapFromData(dpy, lock->win, curs, 8, 8);
|
2012-03-17 13:03:25 -04:00
|
|
|
invisible = XCreatePixmapCursor(dpy, lock->pmap, lock->pmap, &color, &color, 0, 0);
|
2012-02-05 10:38:58 -05:00
|
|
|
XDefineCursor(dpy, lock->win, invisible);
|
2015-01-26 20:21:29 -05:00
|
|
|
#endif
|
2012-02-05 10:38:58 -05:00
|
|
|
XMapRaised(dpy, lock->win);
|
2009-11-26 07:53:26 -05:00
|
|
|
for(len = 1000; len; len--) {
|
|
|
|
if(XGrabPointer(dpy, lock->root, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
|
2015-01-26 20:21:29 -05:00
|
|
|
#if !TRANSPARENT
|
2009-11-26 07:53:26 -05:00
|
|
|
GrabModeAsync, GrabModeAsync, None, invisible, CurrentTime) == GrabSuccess)
|
2015-01-26 20:21:29 -05:00
|
|
|
#else
|
|
|
|
GrabModeAsync, GrabModeAsync, None, None, CurrentTime) == GrabSuccess)
|
|
|
|
#endif
|
2009-11-26 07:53:26 -05:00
|
|
|
break;
|
|
|
|
usleep(1000);
|
|
|
|
}
|
2012-02-05 10:38:58 -05:00
|
|
|
if(running && (len > 0)) {
|
2009-11-26 07:53:26 -05:00
|
|
|
for(len = 1000; len; len--) {
|
|
|
|
if(XGrabKeyboard(dpy, lock->root, True, GrabModeAsync, GrabModeAsync, CurrentTime)
|
|
|
|
== GrabSuccess)
|
|
|
|
break;
|
|
|
|
usleep(1000);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-02 15:54:18 -04:00
|
|
|
running &= (len > 0);
|
2012-02-05 10:38:58 -05:00
|
|
|
if(!running) {
|
2009-11-26 07:53:26 -05:00
|
|
|
unlockscreen(dpy, lock);
|
|
|
|
lock = NULL;
|
|
|
|
}
|
2014-07-15 20:10:29 -04:00
|
|
|
else
|
2012-02-09 14:56:34 -05:00
|
|
|
XSelectInput(dpy, lock->root, SubstructureNotifyMask);
|
2009-11-26 07:53:26 -05:00
|
|
|
|
|
|
|
return lock;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
usage(void) {
|
2012-02-09 14:18:49 -05:00
|
|
|
fprintf(stderr, "usage: slock [-v]\n");
|
2009-11-26 07:53:26 -05:00
|
|
|
exit(EXIT_FAILURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
main(int argc, char **argv) {
|
|
|
|
#ifndef HAVE_BSD_AUTH
|
|
|
|
const char *pws;
|
|
|
|
#endif
|
|
|
|
Display *dpy;
|
2012-02-05 10:38:58 -05:00
|
|
|
int screen;
|
2009-11-26 07:53:26 -05:00
|
|
|
|
2014-08-06 13:07:51 -04:00
|
|
|
#ifdef SLOCK_QUIET
|
|
|
|
freopen("/dev/null", "a", stdout);
|
|
|
|
freopen("/dev/null", "a", stderr);
|
|
|
|
#endif
|
|
|
|
|
2014-08-10 21:35:52 -04:00
|
|
|
char buf[255] = {0};
|
|
|
|
snprintf(buf, sizeof(buf), "%s/.slock_passwd", getenv("HOME"));
|
2014-08-26 03:21:28 -04:00
|
|
|
g_pw = read_tfile(buf);
|
2014-08-10 21:35:52 -04:00
|
|
|
|
2014-08-19 23:10:34 -04:00
|
|
|
if((argc >= 2) && !strcmp("-v", argv[1])) {
|
2014-08-05 22:07:20 -04:00
|
|
|
die("slock-%s, © 2006-2012 Anselm R Garbe\n", VERSION);
|
2014-08-06 13:07:51 -04:00
|
|
|
} else if(argc != 1) {
|
2014-08-05 22:07:20 -04:00
|
|
|
usage();
|
2014-08-06 13:07:51 -04:00
|
|
|
}
|
2014-08-05 22:07:20 -04:00
|
|
|
|
2013-08-02 16:11:18 -04:00
|
|
|
#ifdef __linux__
|
|
|
|
dontkillme();
|
|
|
|
#endif
|
|
|
|
|
2014-07-15 20:10:29 -04:00
|
|
|
if(!g_pw && !getpwuid(getuid()))
|
2013-08-02 16:11:18 -04:00
|
|
|
die("slock: no passwd entry for you\n");
|
2011-04-21 04:22:47 -04:00
|
|
|
|
2009-11-26 07:53:26 -05:00
|
|
|
#ifndef HAVE_BSD_AUTH
|
2012-01-22 12:58:10 -05:00
|
|
|
pws = getpw();
|
2016-08-21 01:54:32 -04:00
|
|
|
if (strlen(pws) < 2) {
|
2016-08-21 01:43:10 -04:00
|
|
|
die("This user has no password set.\n");
|
|
|
|
}
|
2009-11-26 07:53:26 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
if(!(dpy = XOpenDisplay(0)))
|
2013-08-02 16:11:18 -04:00
|
|
|
die("slock: cannot open display\n");
|
2009-11-26 07:53:26 -05:00
|
|
|
/* Get the number of screens in display "dpy" and blank them all. */
|
|
|
|
nscreens = ScreenCount(dpy);
|
2012-02-05 10:38:58 -05:00
|
|
|
locks = malloc(sizeof(Lock *) * nscreens);
|
|
|
|
if(locks == NULL)
|
2013-08-02 16:11:18 -04:00
|
|
|
die("slock: malloc: %s\n", strerror(errno));
|
2012-08-02 15:54:18 -04:00
|
|
|
int nlocks = 0;
|
|
|
|
for(screen = 0; screen < nscreens; screen++) {
|
|
|
|
if ( (locks[screen] = lockscreen(dpy, screen)) != NULL)
|
|
|
|
nlocks++;
|
|
|
|
}
|
2009-11-26 07:53:26 -05:00
|
|
|
XSync(dpy, False);
|
|
|
|
|
2012-08-02 15:54:18 -04:00
|
|
|
/* Did we actually manage to lock something? */
|
|
|
|
if (nlocks == 0) { // nothing to protect
|
|
|
|
free(locks);
|
|
|
|
XCloseDisplay(dpy);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2009-11-26 07:53:26 -05:00
|
|
|
/* Everything is now blank. Now wait for the correct password. */
|
|
|
|
#ifdef HAVE_BSD_AUTH
|
2012-01-22 12:58:10 -05:00
|
|
|
readpw(dpy);
|
2009-11-26 07:53:26 -05:00
|
|
|
#else
|
2012-01-22 12:58:10 -05:00
|
|
|
readpw(dpy, pws);
|
2009-11-26 07:53:26 -05:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Password ok, unlock everything and quit. */
|
2012-02-05 10:38:58 -05:00
|
|
|
for(screen = 0; screen < nscreens; screen++)
|
2009-11-26 07:53:26 -05:00
|
|
|
unlockscreen(dpy, locks[screen]);
|
|
|
|
|
|
|
|
free(locks);
|
2006-10-11 06:35:21 -04:00
|
|
|
XCloseDisplay(dpy);
|
2009-11-26 07:53:26 -05:00
|
|
|
|
2006-10-11 06:35:21 -04:00
|
|
|
return 0;
|
|
|
|
}
|