Wednesday, September 9, 2020

Interesting times. Hitting a bunch of topics that are more than a little divergent but interesting.

Networking Security

Work keeps me deeply involved on this front. Down in the TLS RFCs, certificate stuff, algorithm and cipher suite options and some lower level work. This may sync well with some home project work as well at some point..later once I’ve gotten some other things back rolling.

WPF

I’m digging deeper into WPF coding for some of the simpler home-front tools. I’ve done a decent amount of JavaFX coding and MFC work but java doesn’t give me access to the low level APIs these tools need and MFC is old, crusty and much harder to work with.

WPF is a bit of an odd critter but seems to fit my needs decently. I’m still working through many of its oddities and figuring out what works well with its design but I’m optimistic that it will remain a good tool for prototyping on windows and for small home tools development.

Unity

Last year I did a good bit of Unity VR programming with a couple of friends.

The year since has been busy as I changed jobs and took on a very challenging set of problems at my new work (cybersecurity, networking security design and fitting it all into an existing architecture that goes back quite a way). I’m hoping that with the fall I will be able to put some more effort into home projects in off hours. Till now I’ve been working during work hours and digging into technology and background issues in off hours.

I’ve got the VR system downstairs back together and calibrated to the room. I’m still eyeing headset upgrades but don’t feel that I’m at the point where I want to throw the money at the systems that are out there.

I need to get back into the basic details needed to build out a VR Unity app. I know I have notes on this blog that will get me there. Once I have that together I’ll move forward with some ‘stretching exercises’ in VR.

I’m also realizing that both the VR environment and the flat screen environment Unity could be a nice environment for some amount of tooling so I’ll probably try to see if PInvoke and similar are supported. Being able to pull information out of a system and then render it and manipulate it in a Unity managed space seems potentially very interesting. With a bit of TLS and networking support and this might get even more interesting. Things to think about.

Rest of it…

I will almost certainly bite off more than I can chew on the home front. Hoping that some interesting bits will make it to a level where they’re useful. I’ll keep blogging here (and on my personal blog and pandamallet for more detailed game stuff). Hoping to reconnect with the friends I was working with a year ago and that a covid vaccine lets us all get back closer to normal life in 2021.

And a Look Back at WPF

Hmm…WPF VIewport3D or Unity 3D rendering. Being able to build a simple-ish windows program rather than something that requires a VR headset does have a sort of charm. Hit testing mouse clicks into the 3D view could be interesting. Choices, choices.

I expect to bump around here a bit.

I really like having the GPU handle display list rendering for me and then being able to change the world while the hardware handles keeping the user’s view consistent.

Seems like it may be worth playing with Unity VR, Unity on a monitor, WPF 3D viewports and perhaps even MFC hosting OpenGL or DIrect3D (Vulkan?). If I can make this stuff work it should prove helpful in many places. Making it work in a more general purpose environment (mostly meaning not Unity) seems alluring as it permits tools to be built with full access to native APIs and facilities.

I think this gives me a direction to head off in that is interesting. I’ll probably still start with a Unity VR implementation as that gives the most ‘bang for the buck’ and should be fun to play with.

THinking that VR Solves Everything :)

After a bit of thought and some time looking at WPF canvas and related items I realized that the same VR environment I planned to use for the random dungeon generator (toy program to play with Unity some more) would make a good environment for putting together an interactive room layout editor.

I was going to try to put together a room drawing tool in WPF. I would prefer to build something like that with interactive drawing as the user moves the mouse. Looking at WPF drawing primitives it seems as if that would get ugly quickly as I really want something closer to a rendering environment. Each frame should be redrawn with updates from any user input reflected.

The 2D APIs seem much more oriented towards static drawings. Update on clicks rather than the 3D style display lists where the image on the screen gets updated continuously. Given the hardware available on even low powered modern computers there is no good reason not to provide this sort of constant, interactive feedback (the equivalent of WSYWG for office tools 30 years ago.

Unity VR provides all of the tools to make this sort of thing happen and should actually provide a very pleasant UI experience along the way. I think I’ll try putting together a map drawing tool as an interesting exercise soon. It may or may not be the final approach but it seems worth trying.

VR Chat

My friend Malcolm suggested using VR chat.

He mentioned spatial.io and VR Chat as options. I registered with both of these as KyleWilson.

So far it looks as if spatial.io does not support any of the PC based 6 DOF room scale devices and since my primary VR system is an HTC Vive this limits my options on that front.

VR Chat looks more promising and I’ll install the windows application tomorrow to see how it looks (it appears to be a steam app).

Just queued it for download on jabberwock (the VR system in the basement). Looks like it already installed…more tomorrow.

Playing with WPF Canvas

I need to put together some 2D-ish editing tools for some home project work I’m doing.

I’m still working my way through WPF panels and controls so that seems like a good place to go with this.

Tonight I’m probably just going to try to get some basic mouse controlled drawing going in this thing. A throw-away toy program with some limited functionality to get familiar with the functions here.

In the end I may very well look at using 3D functions (and perhaps not WPF) to make this happen. Being able to do full renders would allow for some nice effects but if the 2D WPF functions are click enough I may make do.

Cybersecurity and Cryptography

It has been a wild ride this last year.

I’ve gone from someone who pays attention to cryptography and cyber-security to developing network cybersecurity architecture.

I’m always up for a challenge and this one has been a big one. So far things have gone well though.

It certainly has kept me busy as the lack of blog posts or significant GitHub commits will show.

I’m not far more deeply aware of the inner details of:

  • TLS 1.2 and TLS 1.3
  • TLS pre-shared key algorithms
  • TLS 1.3 session resumption
  • AES implementation choices.
  • Cryptographic random number generation and primary entripy source selection (this last a work in progress)
  • Elliptic curve cipher suites for TLS
  • SSH/SFTP protocol details and security implications in there.
  • Modern password hashing algorithms (BCrypt, SCrypt and PBKDF2)
  • Lots and lots of trade-offs between security, performance, implementation time and cost.
  • X.509 certificate details and ways of creating, managing and distributing certificates. PKI both big and small.
  • Some fun with trusted platform modules.

A wild ride indeed and not over yet. If this all keeps coming together though it should lead to a very satisfying conclusion.

This has certainly added a lot of tools to my toolbox. I’m now much better equipped to deal with secure networking issues and implementation. Once thing with network cyber-security work is that there’s always one more detail that needs to be addressed.

I am hoping to free up some time on the home front to get back to some of my home VR software projects this fall. Still dithering on whether to buy a resharper license. I’ll probably pick up ‘cluster’ again and try to move that to a more complete state. Might also play with some smaller VR toy programs…tempted to put together a very small gravitational system simulator in room scale. We’ll see how all that goes. I really need to get back in touch with Malcolm and Sam and see how they’re doing.

A bad Week for Computer Hardware

One of the drives in my disk array just failed this morning. Seems like it has been a bad week for computer hardware here. More irritating at the moment as this is an array and the remaining three disks are keeping things running.

Next step will be locating the failed drive when the replacement arrives sometime in the coming week. The new boot drive helps as well since it has space for working files in the interim.

Last weekend I spent a couple days working through issues around my boot SSD as I worked to upgrade to a 2TB drive to make space for working files on the fast volume. I remain nervous that this machine may start seeing more failures as it gets older. For now it is still doing reasonably well.

Working from home makes my local systems that much more important. I’m doing quite a bit of prototyping that involves network activity. My work laptop can’t see anything local once the VPN is engaged so all of the things I could have done with a USB network adapter creating a small local network for experimental use are off the table when I’m home. I have more compute resources on my home network than I have at work so this isn’t a big issue…but when my local systems have problems that spills over.

Hoping this will get me past most of the problems and next week will be smoother.

Software Process

I watched a few conference sessions talking about software process yesterday evening.

Agile

There was one discussion of agile that I really liked. I’ve seen quite a few parts of agile processes that I think add value but I’m not convinced that the overall processes map well to the sorts of large, embedded software projects that I’ve generally been involved with.

Technical Debt

Another session made some very good points related to dealing with technical debt. The presenter had some very interesting thoughts on using source code control system information to direct refactoring efforts. It makes sense that modules with significant complexity and lots of ‘touches’ are good candidates for clean-up. He also made the excellent point that attacking issue counts will focus everyone’s attention on the small, low risk, low reward items that can run down the count quickly. Dealing with a thousand minor naming issues will do little to improve tangible code quality. Addressing a single, large snarl of complex interactions may result in huge improvements. I long ago realized that uncritical use of metrics can derail a team faster than anything else.

Functional Programming

There was also a short functional programming session that seemed decent. It still didn’t address my biggest pain points with functional though.

He made a decent case for the merits and limitations of functional approaches. I tend to buy them for ‘business logic’ type work.

The place I run into trouble with functional (and to a less extent the JVM languages in general) relates to numerics work.

I’ve spent a chunk of time processing images and signals. I still don’t see how one can reasonably implement something like noise reduction or sharpening of a reasonable size image (say 5000 x 5000 RGB pixels) in a functional language. Immutable arrays would seem to leave the developer with a lose/lose/lose set of choices.

  • Direct approach – Process each pixel in series and create a new image array with the updated pixel. Repeat this 5000×5000 time, copying the array at each step.
    This obviously fails even in a garbage collected environment as the process of copying megabytes of data for each pixel update will kill you. It does mean that access to adjacent pixels should be reasonably fast as reads will be no different than in a procedural environment.
  • Partitioned Tree approach – Build your large array as a tree structure under the covers with (say) 32 elements per leaf node. This was the approach suggested by the presenter in the talk.
    This seems to be the worst of all possible worlds. Read access to each pixel requires traversing several levels of pointer indirection. If 32 pixels in a row are updated then we generate 31 ‘dead’ copies of the segment along the way. Locality of reference becomes a mess as adjacent items in the ‘array’ may be anywhere in memory.
  • Process and Reassemble approach – Run through the entire source image and generate a change list to be applied. Once you’ve finished with the image, generate a new array with all of the specified changes in place.
    This will potentially generate a list of tens of millions of update entries in memory. I’m also not sure how one implements the ‘create a new array based on this array with these updates’ in an immutable environment. I guess this is the bottom line of all of the functional coding I’ve run across…the functional environment seems to always assume that there is procedural ‘magic’ to make the ends meet. I suspect that the answer would involve writing the image processing primitives in a ‘real’ language and then exposing them as unitary operations on the functional side. This rather strongly suggests that functional languages will always be a specialty item and not the ‘main course’.

Weekend Update with Blender and Unity

Pushing forward with Blender 2.8 and unity with more detailed comments here.

Creative Things

Looking to be a varied and busy winter and spring. I’m hoping to move my unity and blender knowledge forward significantly. I want to get Cluster to a point where it is more a game and less a sand-box for VR experimentation.

Work

Work looks like it is going to be a wild ride as well as I step into a cyber-security role in a big way. I’ve got to finish defining the network and local security design for the product and generate sufficient documentation to convince the FDA that we’ve done our due diligence. Should be do-able but I’m expecting it to keep be very busy.

OpenSSL

I’m looking at getting a Visual Studio 2019 debug build of OpenSSL together locally as well so that I can look into some functionality that I want/need to understand better.

In particular, the ‘envelope’ functionality that provides encryption at rest with multiple access based on private key encryption of a one-time symmetric key could solve a variety of interesting problems.

I need windows (and ideally bcryptlib) based versions of this functionality that inter-operate with the OpenSSL version if possible. Being able to build some sample code and then step through with the visual studio debugger would help quite a bit.