start	end	text
22840	28480	Cool. Thank you very much. And I really appreciate being here, and I really appreciate your time.
28480	32080	So I'm more than happy to answer any of your questions. I'm looking mostly at the Discord
32080	37000	channel right now. My beard is awesome, and I'm not on a boat, but I wish I was.
37320	43340	But just kind of... I didn't plan this out here, but you gotta respect the beard here.
43380	50520	So on more serious questions here, I guess, what can I do to help answer?
53020	60300	And so Markov, it really has very little math actually in it, too. It's just multiplication.
60380	65980	So if you can do multiplication, there's not even any division. So you just look at the
65980	69660	probability of one letter falling after another letter, falling after another letter there.
69700	75720	And the more letters you have, the higher probability it usually is. Omin gets a little
75720	81140	bit more complicated because they have this idea behind it called levels. But then you do it with
81140	84880	some multiplication, and you just do addition instead. So the final level, the password,
84880	88820	is summing all the levels across it. And the reason why you want to do that is because that's
88820	93780	much faster than trying to do a more traditional Markov attack like you would see in John Ripper
93780	98620	Markov mode. But there's a million different ways that you can do Markov. So I could talk
98620	101840	to you all day about that if we want to just go ahead and get into that.
103860	108900	Hashcat needs to update its Markov ability, though, because it is probably, of all the
108900	117750	algorithms, the worst. But Hashcat's really fast, so it can get away with that. And I know you're
117750	121470	just trying to be cheeky about that, but here's a... just trying to give you an answer to that,
121470	140150	because I really enjoy it. It would be nice... the challenge is that the guest generation
140150	149370	port could probably be extracted out, but figuring out what kind of rule to use is pretty
149370	155810	much single-threaded, unfortunately. And that's really what takes all the time, is just trying
155810	160350	to figure out which of the rules is currently the most probable in order to run. And that's why it
160350	165330	takes so much memory, because it's basically building a probability queue of all different
165330	170130	probabilities. It's going through... it has a kind of a tree type of a format there. So,
170130	174690	long story short, I wish I could figure out how to do that. But where you're probably better off
174690	179330	doing is, instead of trying to generate all the guesses in probability order, you could actually
179330	183710	just go ahead and generate guesses behind a different probability threshold. So, all these
183710	188370	guesses that are higher probability than this level here. And in that case, you could absolutely go
188370	193950	ahead and multi-thread it for GPU. So, I've actually talked to some people about potentially
193950	197590	getting this in a way so that you're not doing probability order, but you set that threshold,
197590	201430	and you could actually run this in the GPU. And it's the fact that GPUs have more memory now,
201430	206470	means you can start putting the base grammar inside GPU as well to help speed that up.
207330	212770	So, I'm sorry, I should ask, answer, respond to the question here. So, the question was,
212770	219050	could I run multiple PCFGs at once on multiple different GPUs? So, the short answer is,
219050	223470	theoretically, yes. But I could definitely use some help in actually coding that up
223470	243420	with somebody who's smarter than I am. So, does anyone else have any questions here? Or I could
243420	253480	just keep on rambling here, too. So, one nice thing is being able to run this against a password
253480	258360	list that you're currently cracking, too. Because it does do a pretty good job of stemming that and
258360	264260	creating some really interesting input dictionaries for you to be able to use. So, if you're kind of
264260	269840	going ahead and doing kind of like a fingerprint attack, just kind of run it around again there,
269840	275280	it can actually extract some really useful bits for that to keep on launching against people.
290170	294970	So, since I got like nine minutes left here, unless someone else asked a question. Oh,
294970	299030	ramble away. Okay, sounds good here. So, the question is, or I guess what I could start
299030	305550	talking about is where password crack PCFGs are kind of going in the future. So, one of my big
305550	309890	goals is I really would like to be able to get incorporated into Hashcat. I started, you know,
309890	314490	brainstorming that quite a while ago. That's part of the reason also why it uses the compiled C
314490	319210	version I wrote it in the first place was because Hashcat, for some reason, does not actually run
319210	327270	in Python because it's fast, I guess. So, that is, you know, ultimately kind of the end goal
327870	334250	for that effort there is to actually incorporate it into Hashcat as a new cracking mode. The
334250	338550	initial way I'm going to start looking at is actually having it run as a, Adam calls it a
338550	344290	slow guesser mode, which pretty much defines this exactly. So, I want to be able to incorporate that
344290	349470	as part of the Hashcat slow guessing modes that you can add in. Eventually, though, I would like
349470	354990	to be able to start going ahead and seeing whether I can go ahead and paralyze the way it generates
354990	359910	guesses and put into the GPU to make it much, much faster. So, there's other options too that
359910	366850	potentially you could basically do... what really slows it down is generating all those rules.
366990	371650	So, in an older version, I had actually had the ability to go ahead and pre-compute all those
371650	377050	rules and be able to save those to disks. So, you could actually then completely paralyze it if you
377050	381110	wanted to as well because there's no rule generation. So, that's another thing I could
381110	386490	take a look back at there. The problem is that the rules are really fine grained. So, I almost
386490	392070	want to go ahead and, in order to reduce the size of the rules on the disk, is to
392070	397110	make the rules much kind of fatter, essentially. So, each rule would correspond to more password
397110	401890	guesses. But that's definitely an option that I'm kind of looking at as well, is to make this
402310	413690	more feasible to be able to be used. So, is there such a thing as a random PCFG rule? Are they
413690	421470	human-readable or, well, geek-readable? So, the short answer is yes. So, if you hit this kind of
421470	427490	status output of when you're running a PCFG, a cracking session, you'll kind of print out the
427490	434370	text screen of what the current rule set looks like. And it looks a lot like a hashtag mask,
434370	439070	actually. So, it just has a few extra different features onto it there. So, you'll see something
439070	446990	like the... I use A for alpha string, but A5, so you know it's generating a
446990	451710	five-letter word. And it'll have a number next to it saying what the
451710	457550	probability, or ranking, I should say, of that five-letter word is. So, it'll say the
457550	463590	153rd most probable word, or number one. So, it'd be the first most probable word. So, that'd be
463590	466830	password. So, in that case, you can kind of read it, and then you can see what the capitalization mode is.
466830	471210	So, it'll say the most common capitalization mode for this here. And it'll say D2,
471210	475630	and it'll be a number after that, too. It's the third most common two-letter, or
475630	482310	two-digit number. So, you can kind of look at that and see what that rule is. So, because the way
482310	488870	that it happens there, you could absolutely go ahead and create a random rule for that.
488870	492990	Or you can just kind of look at it and read what it's actually doing. And so, you can go back to
492990	497910	the grammar and say, okay, what is actually the 143rd most probable word? And it's, okay, so that's
497910	502930	the word that it's using. And if the words have the same probability, they'll use just all of them
502930	506590	there. So, there might be multiple different words that you only saw in the train set, let's say,
506590	513090	twice. So, they'd all be used to the same probability in that rule. You can also create, when talking
513090	517510	about random passwords, some work I did in the past was creating what's called honey words. So,
517510	523550	these are passwords that look like human passwords. And PCFGs are really good for that. So,
523550	527050	instead of trying to create the most probable password, you do a random walk through the
527050	530710	grammar. And that way, you know, 1, 2, 3, 4, 5, 6 is still going to be very common. You're going to
530710	534210	create that much more often than normal. But you also create some kind of random looking passwords
534210	538570	too. And where this is really useful, for example, is if you're trying to set out a honeypot server,
538570	544070	and you want to do like a honeypot Active Directory controller, and you don't want to go
544070	550250	ahead and manually create a thousand different passwords for different fake users. So, that way,
550250	554890	you can go ahead and run that. And you create passwords that, you know, if you glance at it,
554890	558390	it looks somewhat real. You're still seeing like the really common passwords. You might see the
558390	562970	company names, you know, the most common there. But you're still seeing some random other stuff
562970	568290	as well. So, that's definitely some work. And improving upon that is I'd like to be able to
568290	573350	create one that or a modification that where it has a biased random walk. So, that way that you
573350	576830	can create passwords that look like they all came from the same user, but once again are, you know,
576830	581410	somewhat different. So, that's definitely an area that's kind of fun to play around with.
590400	594840	What have you seen in terms of variance between, say, company one and company two? So, that's just
594920	602420	a question that was asked. And a short answer is I really haven't seen that. And by that, I mean,
602420	606600	I'm a researcher. This is a hobby for me. So, almost every single dump that I've worked with
606600	611980	has been, I would say, the public dumps. And while there definitely are company passwords that,
611980	618900	you know, get pushed out there, especially if you look for, like, NTLM. But I'm a researcher. So,
618900	622960	you'd actually have to ask, you know, someone like, you know, CoreLogic about that there. So,
622960	625900	I'm not a really good person to answer. And that's why I'm always really interested in hearing these
625900	629680	talks and talking to people who are actually doing this professionally. Because they're able to
629680	633640	provide me that information there. But pretty much all I have from that is secondhand.
639700	642840	So, we're getting to the end here. It looks like there's just a couple more minutes. So,
642840	648500	if anyone has any questions, feel free to ask them. Otherwise, I really do appreciate you
649000	653500	coming in and, you know, viewing this talk. As I said, I'm available on Twitter,
654440	660600	at L-A-K-I-W. And if you really want to get in touch with me, the best way to do it is
660600	667100	submit an issue to the GitLab repo. That's probably the best way. Because I pretty much
667100	671040	obsessively track that there. And I'll definitely try to get back to you. But this
671040	674320	is something that I find is really fun. And I really do appreciate you taking an interest in
674320	687670	this. Cool. Yep. And I'll be on Discord for the rest of the weekend, too. So,
687670	689830	if anyone has any questions, feel free to pop in there, too.