https://nekopy.neocities.org/feeds/all.atom.xml

Well, I installed Arch. Kinda. Fearing the inevitable forced push to Windows 11, I was casually on the lookout for my next distro. There's one I keep seeing in ads on google whose name I incredibly can't remember despite all the articles I've read about it. I've also always wanted to try void linux. But my main issue is that I've built myself a rather nice little gaming rig, and I'd rather be able to you know, actually use that beefy graphics card in there for something other than running AI models. Then, and I don't even remember how, I stumbled onto Garuda Linux.

Now I know, you're asking yourself, why the hell would you pick up some gimmick distro like this when you could grab something nice and stable like Ubuntu instead. Well yes. Garuda is a rolling Arch release and is therefore sort of a moving target to keep up to date and running properly. Now my ideal Linux distro for my gaming rig has the following goals:

1. GPU and hardware support
2. Can play modern PC games
3. Good for development (though lower priority - I develop on my laptop mostly these days).

So, it seems that Garuda's gaming flavor actually checks a lot of these boxes for me, quite unexpectedly. To be honest, I come from a time when "compatability" with gaming related stuff on Linux was a pipedream. To be honest, I think that the importance of Nvidia drivers on linux for AI development alongside the introduction of the Steam Deck were a one-two punch that must have forced progress forward.

So far I'm about 3 days into it and it still feels good, and I've had very little issues in terms of compatability. I'm running everything from built-for-linux games to the new Silent Hill remake with no issue. Take a look at some of the one-click install emulators:

Here's a few features I'm really excited to have.

Lutris is a frontend for launching and installing games from a bunch of different launchers. It's a really convenient way to both see your entire library and be able to add stuff like launch configurations.

Snapper automatically does system backups when you use the package manager on the system or do other weird stuff. So far I haven't had to rely on it, but I'm quite glad it's there.

Immediately became my new browser of choice. Floorp is a new privacy focused firefox derivative from Japan. It has even nicer security features cooked into it than base Firefox, and a lot of the nice features of Opera too.

Bat is a cat replacement on the CLI which lists file names with colored syntax highlighting. Instant win.

Starship is a status line rice tool that comes with some pretty nice defaults stock with Garuda. It's highly platform agnostic which means it syncs very easily with my old Debian install as well.

Chezmoi is a replacement I grabbed after I found that yadm had been deprecated. It has some really advanced features around encryption and templated dotfiles, and despite it having a bit of a learning curve I'm liking it better than yadm already. Note that I installed this myself - it wasn't part of the distro out of the box.

Nerd fonts and emoji fonts are preinstalled, and the default is FiraCode mono with code ligatures - my absolute favorite programming font.

The shell rc is already heavily tricked out with some very nice options. This is where I learned about bat and exa. I directly stole a ton of the aliases for myself.

# Replace ls with exa
alias ls='exa -al --color=always --group-directories-first --icons'     # preferred listing
alias la='exa -a --color=always --group-directories-first --icons'      # all files and dirs
alias ll='exa -l --color=always --group-directories-first --icons'      # long format
alias lt='exa -aT --color=always --group-directories-first --icons'     # tree listing
alias l.='exa -ald --color=always --group-directories-first --icons .*' # show only dotfiles

# Replace some more things with better alternatives
[ ! -x /usr/bin/bat ] && [ -x /usr/bin/batcat ] && alias bat='batcat'
alias cat='bat --style header --style snip --style changes --style header'
[ ! -x /usr/bin/yay ] && [ -x /usr/bin/paru ] && alias yay='paru'

# Common use
alias grubup="sudo update-grub"
alias tarnow='tar -acf '
alias untar='tar -zxvf '
alias wget='wget -c '
alias psmem='ps auxf | sort -nr -k 4'
alias psmem10='ps auxf | sort -nr -k 4 | head -10'
alias ..='cd ..'
alias ...='cd ../..'
alias ....='cd ../../..'
alias .....='cd ../../../..'
alias ......='cd ../../../../..'
alias dir='dir --color=auto'
alias vdir='vdir --color=auto'
alias grep='ugrep --color=auto'
alias fgrep='ugrep -F --color=auto'
alias egrep='ugrep -E --color=auto'
alias hw='hwinfo --short'                          # Hardware Info
alias ip='ip -color'

if [ -x /usr/bin/fastfetch ]; then
      fastfetch
fi

I didn't even know ip had a color mode. The future is now. Speaking of one-click configurations, here's a few more:

Wow was not expecting to be saying this but I guess linux has come really far since the old days. I just played the demo for a VR fishing game on Steam, on Arch linux. It's definitely more clunky than on windows, but it's running just fine. I think I need to fiddle with the FPS a bit but wow for real. That's awesome.

I'm perfectly happy here. I think the one annoying thing is needing to update the system all the time but that's Arch I guess. I sure as hell won't be going to Windows 11 anytime soon. I need to cut this short or else I'm never going to publish it. I'll be sure to update later if I have any serious updates.

Web radio... seems like a blast from the past huh? Well I've been listening to some excellent free stations for a while now and I figured I'd save them here before I started forgetting URLs. I'm giving the direct stream links here rather than the landing pages so you don't have to fuck around looking for them.

Pair of excellent radio stations from lainchan.org. If you listen to anything on this page, I'd recommend the Cyberia link.

• http://lainon.life:8000/cyberia.ogg
• http://lainon.life:8000/cafe.ogg

Hell yeah. Some classic true chiptunes. For when you're in the mood for blips and bloops. I discovered some of the epic producers from the old demo days on this site like Laxity! From what I can tell, a large portion of the hot SIDs they got are from the Unepic Stoned High SID Collection. The site has gone through its highs and lows over the years. If you can donate, do it.

• http://kohina.duckdns.org:8000/stream.ogg.m3u

Yep touhou music. Can't help it, sometimes I'm just in the mood for it.

• https://stream.gensokyoradio.net/1/

Freeform radio! I remember listening to Liz Berg's wacked out radio show back in the day. Crazy music interspersed by Liz randomly going on some drug-induced tirade between songs with no explanation. Their stuff is still good. Check it out.

• https://wfmu.org/wfmu.pls
• https://stream0.wfmu.org/rocknsoul
• https://stream0.wfmu.org/drummer
• https://stream0.wfmu.org/sheena

Free web radio from a nice masto instance.

• https://radio.hackers.town:8000

I'll add to this if I realize I forgot something...

With the rise of machine learning software (you can't say "AI" or else people will shriek about it) there has been great advances in many fields, such as mass surveillance, enhancement of vehicle ticketing systems, and many other awesome things that improve our lives day-to-day. But beyond these pleasant improvements to our daily lives as cogs in the corpo machine, there has also of course been the rise of systems designed to entertain us. DLSS from NVidia is being used to do bangin' upsampling in modern games such as the much discussed Cyberpunk 2077, virtual waifu software like xiaoice, and face detection based filters such as you see in zoom and snapchat. One thing that stands out to me are games built on generative text systems such as AI Dungeon.

If you haven't heard of it before, AI Dungeon is a text-adventure system where your choices are interpreted by a generative text model - that is, some ML that can generate text - and spits back a response. So you say what you do, and then AI Dungeon will say what happens, or in some cases put words in your mouth. It's a pretty fun system, and their more powerful "Dragon" model is based on GPT-2 from Open AI. The GPT line from Open AI is some pretty cutting edge stuff, although GPT-2 has since been superseded by GPT-3.

Machine learning models work generally by taking some input (in our case, text) and running it through a series of transformations, much like matrix transformations you'd see in game development, although these transformations are intentionally nonlinear. The goal of these transformations is to take the input and be able to do something interesting with them. Perhaps with a image processing model we could tell if something is a hotdog or not by transforming the pixel data to a space that gives a probability of hot doggyness. Doing this involves setting many internal numbers used for this tranformation (namely weights and biases) which are used to encode the transformative operations on the input data to reach the output space. During training of the model, the weights and biases are tuned algorithmically in order to maximize success (reduce a metric called "loss"). It works like this. You take some data which you already know whether it's a hotdog or not, preferably a huge fuckton of images of hotdogs and not-hotdogs, and split it into a training data set, and a validation set. You feed it training data, and based on whether it got the answer right to the question, the weights are adjusted. The algorithm used for this is called gradient descent. In doing this, the model is really learning to be good at classifying (or whatever result you want) the training data. Then you test it using the validation set you set aside to see how well you've done. There's some inherent risk in this. If you train too much on the training data, you get to a point called "overfitting." When a model is overfit, it has basically memorized all the training data rather than learned how to generalize the problem and classify all sorts of images.

Imagine if we have an overfit model for a text generator. It's been fed a bunch of partial sentences, and has memorized the sentence completion. Remember - a text generator is really just doing the task "finish this sentence." A good text generator will finish the sentence by producing something believable to be the output. However, an overfit text generator will do it by spitting out the rest of the sentence it trained on. If we are interacting with an overfit text generator, we can recover the training data simply by enumerating sentences and recording the results. And what if private information, like email addresses or credit card numbers were encoded in the training data? Or what if the training data is a company secret? Suddenly we have a big issue of leaking training data. However, machine learning models are designed not to be overfit, especially for this reason.

However however, it has been shown, such as in this paper from a bunch of intelligent folks and big corps that in language models (specifically GPT-2!) that even when a model is not overfit, we can still retrieve verbatim text sequences from the training data. Now, GPT-2 itself as a demo was trained using Reddit (god can you imagine forcing an AI to become a redditor? This kind of shit is why Tay.ai became a nazi). However, when you use GPT-2 yourself, you train it on other data that's relevant to the subject matter at hand. So we might be interested in what kind of data was used to train AI Dungeon's Dragon model.

Out of curiousity, I took a stab at it. I expected that certain highly-unique start-sequences (for example, "Copyright" or "ISBN Number") might have been memorized instead of generalized due to their infrequency of appearance in text. Once you're in an AI Dungeon game, there are certain settings you can use. If you use the "Creative" mode, you can feed text undecorated directly into the system. So it's easy, put in an interesting start-sequence, and let it run. You can hit the refresh looking button for it to regenerate. Let's try with the start-sequence "Copyright"

Copyright (c) 2016 by J.A. Michaels
Copyright (c) 2016, Ian T Smith.
Copyright (c) 2016 Ian Cheyser

Now, we need to make an informed decision as to whether or not the results coming back from this are really memorized or if they're just the model making up something that fits a copyright pattern. One of the hits I got in practice was a Copyright for "kain pathos crow." I thought this was pretty interesting since it's a really unique name - not really something we'd imagine as a common copyright. So let's google the dude.

Bingo. This looks like a good hit. This guy is on deviantArt making literature. What's more, it seems like it's in a format which might be easy enough to insert into a training set.

We can also do the same thing with "http://"

http://www.writerscafe.org/
http://www.sincomics.com/ (LINK REMOVED)
https://www.wattpad.com/

Note that a lot of the stuff that was generated was bogus. It's pretty clear that the model seems to have a general idea of what some URL formats look like, however the ones above seem to be reasonable stuff that might have been used for initial training.

There are some other interesting properties. Dragon seems to have learned how to create youtube video links, ISBN numbers, email addresses, and telephone numbers.

Additionally, there seems to have been some attempt at scrubbing personal information and some links, such as the (LINK REMOVED) text you see above. If you try putting in "Call me at" then it will complete the sequence with some underscores, indicating that phone numbers were scrubbed prior to training. Also, somewhere along the lines, links were removed in the data cleaning process.

What can we learn from this, or how do we go deeper? If we wanted to really scrape out lots of training data, the next step would be to identify some high quality start-sequences and build some software to hit the system over and over with them, and keep ones that look good. For URLs this is simple. Just grab the URL in the output and try to dns resolve it. If it works, it's likely something memorized in training. If not, it's something the bot learned to cook up. We've found that ISBN numbers aren't a good signal, because they tend to just be random numbers in ISBN format. I tried, and whenever I did ISBN lookups, it came up bogus. Although, even there we do learn that the model was likely fed the content of entire books during training as well.

How certain are you about the results? Not at all. Well sort of. With results like our friend Kain, we can be certain of one of two things - his work was either used in initial training, or he uses AI Dungeon to write stories, and his interactions with the system were reused to train the system again, and for whatever reason he decided to put a copyright into the game while he was writing. However with results like the regular names we got, we can't really be certain these are real people.

We also learn a little about the training data from the fact that most of the copyrights that come back are from 2016 and 2017, which indicates this is likely when the training data was collected.

Well, what can we do with all this? Like most of my articles, not much. This is more of an exercise in curiousity after all. If we wanted to train a similar model, it would be useful as a jumping off point for collecting training data of your own, but it would still need to be cleaned and prepared for use in an ML model, and really that's the hard part aside from deciding on model architecture. But hey, this was fun, wasn't it? Go play with AI Dungeon's (awesome) Dragon model yourself, and see if you can learn anything about it. Or just, you know, have fun. It's a great little game.

stay comfy

In today's world of blogs, google drive, instagram, and facebook, there is very little information about many peoples' daily lives that is not shared. If facebook is still around 100 years from now, what will happen to the accounts that were created today? Or for that matter, what happens to our facebook accounts after we die? Facebook has already thought of this, and there is an ability for you to report to Facebook that a user has died. When someone dies, if you can reasonably prove that they are dead, Facebook will "memorialize" the page, which freezes it and leaves it like a digital time capsule. It's unclear what the retention period for accounts like this are. If Facebook sees marketing value in keeping something like this around, your great-grandchildren may be able to go back in time, and see your facebook page from today. Even if Facebook doesn't retain your data indefinitely, there's a chance that some post you make will wind up in archive.org, or squirreled away by a group like Archive Team.

Facebook isn't the only organization that has a death policy. Deep in your Google settings you can configure an "inactive account manager." If Google doesn't detect activity from your account in X months (i.e., you're dead), then you can configure it to perform certain behaviors, such as granting another google user temporary full access to your accounts, and even send a digital message from beyond the grave.

This dystopic hellscape of a post-privacy society has an interesting side-effect: it makes anthropologists' jobs much easier. Anthropologists currently have very little information about the daily lives of people, even those who kept diaries, because the things that people write about in long-form diary entries have very little information about the commonplace. Even photograps or drawing of streets can provide more information than the ramblings of a diary.

If facebook retains data from old accounts for a long time, will it eventually open up accounts hundreds of years later? Should it? The potential for that amount of data could make history much less of a guessing game. Broad information about major events will be much easier with things like Wikipedia existing, but potentially, samples of ancient social media profiles could provide the full picture of what society is like.

What do you think? How would you feel about your social media profile being used in this way?

So you want encryption on Windows. There's really 3 different layers of encryption you can do. Your first choice is to encrypt the files you want to protect manually by hand. This is extra EZ using something like 7zip. However it's super inconvenient. Everytime you want to access your protected files, you need to decrypt and unzip, then zip back up. Also, if you want to add anything to your secure archive, it's equally a pain in the ass.

Your next choice would be full disk encryption, which is a pretty good option. In this case, your filesystem is encrypted. This means that everything you drop on your disk is encrypted until you enter your password to mount the disk. This is the kind of thing you can get out of the box when you install linux usually. The downside to this is that everything in your partition is going to be encrypted, and there's some issues with portability. If I have a linux box and I want to dual boot, there's potential for fuckery when trying to mount your encrypted disk on windows, or vice versa because of windows' refusal to deal with other FS standards than FAT32 and NTFS. To be honest, the same could be said about Linux's refusal to add ZFS support (although that's changing! Ubuntu is putting its dick on the table and adding experimental ZFS support).

Then you can sit in the middle. In this case, you can add an abstraction layer on top of your filesystem, where files in a specific folder are encrypted. This is like what you get with eCryptFS or SecureFS. In this case, your files are portable and decoupled from the underlying filesystem. When you unlock your folder, it creates a mount running a virtual filesystem which provides the decrypted versions of the files. When you write, it automatically encrypts the files onto the original location on disk. The portability gains here should be obvious. In many cases, you can simply copy files and put them on a USB drive or email them individually.

In the case of SecureFS, there is a manifest file which sits alongside the encrypted folder. In my case, it's a JSON blob that looks like this:

{
    "block_size" : 4096,
    "encrypted_key" : 
    {
        "IV" : "BLAH",
        "MAC" : "BLAH",
        "key" : "BLAH"
    },
    "iterations" : 65536,
    "iv_size" : 12,
    "pbkdf" : "scrypt",
    "salt" : "BLAH",
    "scrypt_p" : 0,
    "scrypt_r" : 0,
    "version" : 4
}

Without the manifest, the folder cannot be decrypted even with the password. You could store it separately and use it sort of like a 2FA. So SecureFS is great, but it's a command line tool. And who can be fucked to use CLI tools on windows? More seriously, there's a cross platform tool called SiriKali which can be used to mount these kinds of virtual filesystems, automatically unmount them, manage them, etc. It's a convenient little system tray tool. However, it doesn't come with any encryption tools like SecureFS. So it's easy, you just download a compatible binary like securefs and put it... uh...

well fuck. As some of you smarty bois may have guessed, the place you should put these files on Windows is any folder that's in your path. In my case, I added it to my system path. Note that restarting SiriKali is not enough. You must reboot your computer. From there, we can go ahead and add a Favorite to create a quickly mountable bvolume that even has an idle timeout option. Although, I have no idea what units the timeout is in. Minutes? Hours? I assume minutes.

Once that's set up, you can install SiriKali just as easily on your linux partition, and easily share a securefs + NTFS volume between the two.

put the backend executables somewhere in your system path and reboot.

Stay comfy

I'm about ready to turn in for tonight. I've been planning on making my next blog post a shining review of the newly released decentralization appliance, the Freedombox. However, right now my freedombox is sitting off on my desk with its brain preparing for a forensic analysis in Kali. How did we get here?

It started while I was sitting on my computer. I was acutally about to run a virus scan for what I thought was a false positive on my laptop, so I rebooted to safemode with networking, but I was unable to join the network. My wife complained about the network being unusable, so I looked at the status of my router on my phone. Nearly 100% CPU usage. Resetting the router did nothing. I managed to get onto the web UI, and immediately went to check connections. The connections showed a ton of connections going to my freedombox. My first guess was that the tor node running on the freedombox had suddenly gotten too many inbound connections, so I disabled tor on the freedombox, but the problem only started getting worse. I was unable to do anything on the router at all. At this point I pulled the LAN cable out of the freedombox and suddenly the CPU usage on the router nosedived and it was accessible again. Next, I pulled the WAN cable out of the router, and plugged the freedombox back in. Now, I checked the web access history on the router for the freedombox and it was full of sketchy chinese websites such as 388wj.com. If my freedombox was being attacked from the outside, I wouldnt be seeing weird URLs in the traffic. This means we may have been compromised.

I sshed into the box and realized I didnt have any security tools on the box, such as chkrootkit or lynis. The problem is the instant I create a direct route from the freedombox to the WAN, my router melts and I can't connect to the freedombox. So I shut it down and pulled out the SD crd the system is running on.

Tomorrow, I will run chkrootkit on the box, and potentially try to do some real forensics on it. If I can't solve anything, then I'll have to just reimage the box and install lynis and get backups ready first thing. This is going to suck. I have my calendar saved on the freedombox, but it had been misbehaving already, so it was already scheduled for a wipe. Hopefully I am able to identify something from the SD card and learn something from all of this.

One of the major things that made me want to support neocities is that one of the founders is a big supporter of Web 3.0 and web decentralization. The main way he seems to be supporting it is by IPFS integration in neocities. IPFS is a project I've had my eye on for a while. The concept is simple. It's a blockchain based DHT and P2P network for sharing websites. The idea is simple. You hash any file, and start hosting it. The hash winds up on the blockchain, and anyone else can access the file by requesting the hash. This way, the whole internet sort of works like bit torrent. You connect to the IPFS swarm, and retrieve the internet by peers who are closest to you. IPFS stands for Interplanetary filesystem. The idea is that even if you're on the moon, you could probably retrieve a static website that's hosted on earth pretty quickly if one of your peers on the moon already has it.

However, there's another interesting use case that the neocities guy brought up, and that's persistence of information. If the swarm is wet with some data, even if the original host goes down, the peers will still have it. However, that's a big if, as we'll see shortly.

This website you're reading right now is static data. There's a little pinch of javascript in the theme, but the posts you're seeing are not dynamic. Like a pure function, no matter how many times you visit this page, it will always be the way you see it unless I update it down the line. This is a perfect candidate for storing or caching. When the page is published, each part of the site is hashed and hosted on the neocities IPFS daemon (I guess?). This makes it initially available for peers. When peers go out to retrieve it through the IPFS gateway at ipfs.io or through your local daemon, you temporarily mirror the pages. Here's an example of a thing that you'll probably always be able to see through the IPFS gateway. You can see there that the name of the hash is QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB, which contains some subnodes in it, including the readme node. If you wanted to see this directly through IPFS and you have it installed, you'd run ipfs cat QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB to view it. In the appropriate P2P way, this would go talk to the swarm and retrieve it from whoever has it. If I wanted to, I could then pin it to make sure it stays live in my cache and I can keep hosting it in case the original went down.

However, it should be clear that this is a garbage way to find files. Humans can't remember IPv6 addresses, let alone that gargantuan hash. Also, if that hash is your home page, and you make a change to it, your hash will change when it gets rehosted in the DHT. In order to combat this, IPNS (pronounced iPenis) was developed. The way IPNS works is instead of uploading your index page directly, you publish a pubkey to IPFS, which links to signed information about the latest hash of some resource. Since you have the private key, you can update this. You access IPNS addresses using /ipns/<hash> instead of /ipfs/<hash> A name in IPNS is the hash of a public key. It is associated with a record containing information about the hash it links to that is signed by the corresponding private key. New records can be signed and published at any time.

Yet this still isn't a good solution, because although now we can address dynamic content in a static way, there's still a huge hash necessary to identify your content. Enter DNSLink. DNSLink is a simple concept. If you have control of a domain, you can publish TXT domain records which point to an IPNS resource. The entries look like this:

[neko@shimapan ~]$ dig TXT testipfs.neocities.org

; <<>> DiG 9.10.5-P2-RedHat-9.10.5-2.P2.fc25 <<>> TXT testipfs.neocities.org
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 21953
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;testipfs.neocities.org.                IN      TXT

;; ANSWER SECTION:
testipfs.neocities.org. 3600    IN      TXT     "dnslink=/ipfs/QmdJtiWqGEDsUJqW41aTQcds7U2PzmLDWs8qQ346mNoPkF"

;; Query time: 16 msec
;; SERVER: 173.255.243.5#53(173.255.243.5)
;; WHEN: Fri Mar 01 21:29:31 PST 2019
;; MSG SIZE  rcvd: 124

Here we can see the dnslink record for a well-known neocities test page. Whenever testipfs.neocities.org is updated, this domain record is updated with the new hash. You can see that we're talking about a tradition IPFS resource because it's prefixed with /ipfs/ instead of /ipns/. The way that this is supposed to work is by using the FQDN which has the TXT record instead of the hash during an IPNS lookup:

ipfs cat /ipns/testipfs.neocities.org
> Error: this dag node is a directory

C:\Users\neko>ipfs cat /ipns/testipfs.neocities.org/index.html
<!doctype HTML>
<html>
  <head>
    <title>Hello!</title>
    <style>
      h1 {
        text-align: center;
      }
    </style>
  </head>
  <body>
    <h1>This is a test of the DNSLINK records with Neocities!</h1>
  </body>
</html>

Let's take a closer look at the actual node used in the DNS record:

That's it. That's how neocities' IPFS integration works.

It doesn't seem to work for pages other than that one test page. Let's look at another page:

[neko@shimapan ~]$ dig TXT lainzine.neocities.org

; <<>> DiG 9.10.5-P2-RedHat-9.10.5-2.P2.fc25 <<>> TXT lainzine.neocities.org
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 3317
;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 0, ADDITIONAL: 1

;; OPT PSEUDOSECTION:
; EDNS: version: 0, flags:; udp: 4096
;; QUESTION SECTION:
;lainzine.neocities.org.                IN      TXT

;; ANSWER SECTION:
lainzine.neocities.org. 3600    IN      TXT     "dnslink=/ipfs/QmP2KjhvDgFTDYpQgUqwXu7EjPvPa5sG7nnrWaaSUebHSN"

;; Query time: 5 msec
;; SERVER: 173.255.243.5#53(173.255.243.5)
;; WHEN: Fri Mar 01 21:29:46 PST 2019
;; MSG SIZE  rcvd: 124

Okay, we have a DNSLink entry for this page! But if we try to resolve it or even just try to look at it with ipfs cat, it just times out. This I believe is the behavior exhibited when there is an IPFS entry for something, but the content isn't available in the IPFS network. I'd imagine that the issue is the content isn't being hosted by neocities from an IPFS daemon. It's strange though. It goes to the work of publishing the DNS TXT record and the file is already being hosted by the site, but it's not exposing it over IPFS. I'd like to send the neocities staff an email about this, but I can't manage to find my way back to the page I found in the first place. Maybe I'll update this if I get around to hunting down the email and messaging him.

This webpage will contain long notes about interesting things I stumble upon during my life on the internet.

Additional info:

email fingerprint : 390308cec78f01187395ac7d555819742c9f8800

discord: neko.py#2580

favicon CC-0, from favicon.cc