Posts by Sandra Green4

northernviper4 said:Well, I suppose it’s a bit late to be bringing up a four-year gap now, isn't it? 🤔

Sent from my Sony Xperia using Reddit

Life tends to throw certain changes your way, I guess, but I should be back on the forum by October 2023.

Chloe Cooper10 said:I don't believe anyone mentioned anything regarding a bell or an integer at all🐔

Where are you headed? 🍿

I suppose one can't really just sit down to write a program as if they were merely playing around on a keyboard or something like that. 🤣

I suppose I have about 13 days left of posting on this forum before I step away, and then I guess we won't be catching up again for maybe four years. That is, if the same group of people is still around here by then.🤣

@Chloe Cooper10/">@@Chloe Cooper10. I was wondering, where did you put the header for that, and why isn't there an integer at the end of the function?

It might be difficult to write effective programs this way, and I suspect it would probably be more useful to actually compile the code so that it can be executed, wouldn't it?

If it isn't entirely clear why the program is crashing, you could perhaps try running it through a debugger to analyze the issue, though you would likely need to compile it using the -g flag if you want to retain the source code for reference.

Anthony Nguyen81 said:😁
The final meal 😬

I suppose one could start by taking the Goat across, then returning empty-handed, followed by moving the Wolf, then bringing the Goat back, and finally transporting the cabbage. After that, you would return once more alone before finally ferrying the Goat across the river.
That would total seven crossings, three of which involve returning, two of those being solo trips.

Though, I guess you could always just shoot the Wolf and prepare some goat meat with cabbage instead.😬

Or perhaps it could be done this way:

First, take the Goat, then move the cabbage, bring the Goat back, take the Wolf, and finally bring the Goat across again. 😬

Chloe Cooper10 said:Well, I suppose that logic applies to income tax refunds, but sales tax is really quite a different category altogether. It seems to me that those calculations are handled on a monthly basis. 😁

E: I guess you don't necessarily have to be an expert on every single detail. 😁
ee: I am not entirely sure when you last filed, but I believe they no longer require physical forms or formal requests, since the IRS now handles all refunds and payments for individuals automatically through their own systems.🤔

Are you perhaps an accountant?

northernviper4 said:👍
I suppose you have phrased it in a way now that makes it much easier for anyone to follow😁

In my spare time, I tend to play video games, spend time with my pets, head to the gym, watch various series or movies, do a bit of sketching, and work on my PhD🙂

I generally try to keep my explanations somewhat simplified, unless I happen to be speaking with someone who is equally well-versed in the subject matter, in which case I feel there is perhaps less need to break down every single term.

northernviper4 said:MIT? 🙂 If you ever find yourself working on business application programming, I suppose you'll eventually need to understand something about business processes. Or, at the very least, you'll need to know how to communicate a client's requirements and needs effectively.

Engineering.

I don't think I am really cut out for developing business applications, nor is that really where my focus lies. I suppose I am much more drawn to things closer to the hardware, such as kernel development, writing drivers, bare metal programming, or working with microcontrollers...

If I were focusing on business applications, that would mostly involve higher-level programming languages, whereas I feel I need lower-level ones so that I can actually manipulate the hardware directly.

Actually, my true passion is robotics and machine programming, which, I imagine, requires much deeper access to hardware resources. And again, one tends to gain that through working with those lower-level languages.

What kind of projects do you work on in your free time? 🍿

northernviper4 said:Gregory Smith21, I was wondering if you are still a student or if you have started working yet? Also, what else do you do for fun besides math and programming? 🍿

I am currently a student. Aside from that, I spend some of my time studying electronics, and I also enjoy wrestling and street workouts.

Chloe Cooper10 said:I suppose Wikj mentioned that printing out an Excel spreadsheet is quite a hassle, 🥳
which leads me to believe that we might just be acting like script kiddies, 🥳

To be honest, I don't really have much insight into how those accounting processes actually work, so I guess I'm probably not the most competent person to weigh in on the matter.😬

northernviper4 said:It seems they don't even grasp the basics of a chart of accounts. Whether it's putting together a balance sheet or just recording an outgoing invoice, it's all quite complex. 👍 I suppose it is easy to laugh, but perhaps it takes a bit more skill to explain these things to someone without a background in finance. 🙂

I don't really have any insight into this matter, as I have never personally worked in accounting.

Anthony Nguyen81 said:Of course, but I suppose one first has to figure out how to flip the light switch 😬

I have always felt that the most compelling details are usually found under the hood 🙂

I think we all started out as mere script kiddies before we eventually grasped how everything functions beneath the surface, down to the smallest detail. 😬

For some people, perhaps simply knowing how to turn on the lights is sufficient, and they don't feel the need for anything more.

Personally, I have always been drawn to the core essence of how things work. 😁

Chloe Cooper10 said:Go ahead and keep making fun of me 🙂

I would bet that none of you actually know how to input data into sales tax forms and submit them to the IRS. ☕

Are you an accountant?

Anthony Nguyen81 said:I suppose you can just flip a switch to turn on a light without needing to understand the complex theory behind electromagnetic field propagation, "😬

That might be true, but I guess if one actually wants to understand how things function under the hood, there is quite a bit of knowledge that needs to be mastered and then integrated into a cohesive whole. 😬

Chloe Cooper10 said:😵 how am I supposed to use tools when I don't even understand how they actually work😵
Is it enough to just toss them in a pan with some onions and bacon?😵

That's quite a way to put it, Chloe Cooper10.

Everything is pretty much scripted, so I suppose you really just have to input whatever information is requested, which is usually just a port number or a local IP address.

As for not knowing what things like the TCP/IP protocol or NAT are... well, I guess that probably doesn't matter much if one is just operating as a script kiddie. 😬

Chloe Cooper10 said:I suppose I found myself having to resort to a Google search.🙂
I suppose I am quite qualified. There is just one minor detail to consider, though. For the most part, I am an adult. 🕺

It matters very little whether one is a minor or an adult; I suppose the real issue lies in the fact that some people use hacking tools like Metasploit without actually understanding how they function under the hood. 🤣

Chloe Cooper10 said:I suppose I could wrap my head around even the most basic stuff if I had to.🕺

I don't think you actually need to understand anything at all, really. It seems like being a script kiddie is more than enough to get by.🤣

Charles Jones3 said:It is somewhat like claiming a surgeon knows more than a general practitioner when they both essentially practice different disciplines. Besides, if you are looking to hack or identify weaknesses, you don't really need any Assembly or a debugger; a basic vulnerability scanner that already exists should suffice, unless you are trying to write your own scanner just to reinvent the wheel.

I suppose your issue stems from the fact that you aren't looking at the depth of the process, which makes your perspective seem a bit superficial and perhaps misguided. In computer science, things are studied quite systematically and thoroughly, rather than by avoiding certain segments that one might personally deem unimportant, even if one doesn't fully grasp why they matter.

A vulnerability scanner simply recognizes flaws within its predefined parameters, which are usually vulnerabilities listed in the CVE database that have already been patched.

To find zero-day vulnerabilities, one must locate a software bug that hasn't been noticed yet, which requires analyzing Assembly code since you won't have the source. Then, you have to run the program in a debugger so you can monitor every single process and the state of the memory, just to get a detailed insight into the core of everything.

Charles Jones3 said:The days of hacking where everything was done in C and Assembly are long gone; nowadays, hacking is considered much more elite.

🤣

I wonder, though, how zero-day vulnerabilities will ever be created if everyone chooses to use these "more elite" methods? 🤔

C and Assembly exist at the lower levels, and therefore they are indispensable and will never stop being used.

The problem with all this "elite" stuff is that it oversimplifies things to the point where users of such tools deal less and less with memory management, the kernel, and other essential processes; then, when a major issue arises, they are unable to resolve it due to their lack of knowledge.

The reason why a high-level language like Java cannot compete with Assembly at the low level is that with Java, you will never truly be able to manipulate the hardware directly in a program-to-hardware relationship—perhaps you can manage it through a program-to-kernel-to-hardware relationship, but you lose efficiency there because the kernel restricts access to hardware resources.

I am actually quite glad I realized early on that high-level programming languages weren't really for me, mainly because I wanted to manipulate hardware at the lowest possible level. That is why I focused on Assembly and bare-metal programming, as it allows for a much better understanding of how a processor works.

Whenever someone mentions Java and the Metasploit framework as if they were primary hacking concepts, I immediately realize their level of expertise, and it is honestly quite pitiful.

I would truly love to see how you "hackers" using Java and Metasploit would break into a machine that doesn't use x86, ARM, or some other common processor architecture, without having Linux or Windows installed, and all of that without knowing any Assembly. I am genuinely curious how that would work. 🤣

Anthony Nguyen81 said:I suppose it has been about fifteen years since I was actually in college, so I haven't really dealt with any of those academic matters in a very long time now. 🤣
The devil always seems to hide within the smallest details, I suppose. 🙂

When you take a moment to consider the development cycle of any particularly complex software, I suppose it becomes clear why larger teams of developers are almost always required, primarily because of those intricate little details. A single, minor bug in the code can lead to catastrophic consequences, most often due to the persistent threat posed by hackers. Even in those cases, certain vulnerabilities tend to surface; it seems to me that it is really just a matter of the attacker's specific knowledge and their ability to spot the tiny nuances that the original programmers might have overlooked.

I suppose it could be argued that everything can eventually be disassembled, and perhaps one might find a way to decipher any given mechanism if they were to try hard enough. 😬

Charles Jones3 said:I suppose you might be mixing up apples and oranges here, because I really don't see what the issue is with using Java or Metasploit. In my view, these are programming languages and software tools that no legitimate professional would ever go so far as to call garbage. To be honest, I’ve always felt that Java is one of the most elite programming languages available, and it seems much more pleasant to work with than something as gritty and unforgiving as Assembly.

If you're looking to hack something today, I suppose you really just need the Metasploit framework, and honestly, I feel like there isn't much of a connection to Assembly here; it seems to me that you might be mixing up two completely different concepts.

I suppose one might wonder about the specific methodology used to identify vulnerabilities within a system through the use of Metasploit. Perhaps it involves a certain sequence of steps, though I imagine the process is quite complex and varies depending on the individual approach. 🤔

Most system vulnerabilities tend to stem from the exploitation of buffer overflow bugs within the software. I suppose one typically reaches that point by performing a detailed analysis of the disassembled machine code, which essentially means working directly through the Assembly.

It seems like Akiro might be mistaken, because if you aren't actually proficient in Assembly, you're basically just acting like a script kiddie, I guess.

As I have mentioned before, I suppose it could be argued that Metasploit is primarily used to identify and exploit vulnerabilities that have already been publicly documented and subsequently patched.

If one intends to uncover a zero-day vulnerability, I suppose it is necessary to analyze every single program down to its most minute detail. You find yourself running the software within a debugger, and since you frequently lack access to the source code—given that most programs aren't compiled with debug symbols—you are essentially left with nothing but the assembly code, which you must then painstakingly scrutinize.

I suppose everything eventually boils down to Assembly, sooner or later.

Engineers and kernel developers truly represent the alpha and omega of the tech world, possessing the unique capability to dismantle any platform they encounter. However, I find myself wondering if a professional engineer would ever actually stoop to such a level as to attempt breaking into someone else's systems.

Anthony Nguyen81 said:I suppose one might wonder if this could be considered a basic level. 😬

It is a beginner-level concept, really. However, I suppose one must be quite careful to ensure that no more than four out of eight ASCII characters end up in any single register during the process, depending on whether you are working with a 32-bit or 64-bit architecture, simply because otherwise, you run the risk of causing a buffer overflow. 😬

Charles Jones3 said:I suppose there is a significant distinction between actual kernel development and true engineering, and then there is what passes for hacking these days. It seems that if you want to hack anything at all nowadays, you really just need Java and Metasploit, which has become the primary framework utilized by almost every hacker and security professional out there.

I suppose I have to disagree with that assessment. In my view, an engineer or a kernel developer possesses a much deeper level of foundational knowledge due to the very nature of their profession, which arguably puts them ahead of a typical hacker. It seems to me that any engineer could potentially transition into hacking quite easily, whereas it isn't necessarily true that every hacker can effortlessly step into the role of an engineer.

I suppose I wonder what everyone might think about the current state of Metasploit and those various little setbacks we've been seeing lately. 🤣

I suppose one could argue that Metasploit is really intended for script kiddies who lack the fundamental understanding of how to manipulate memory at the processor level, or perhaps they simply don't truly grasp the underlying mechanics of how a computer actually functions. 😬

I suppose one could argue that the Metasploit framework is essentially just a collection of scripts and exploits targeting vulnerabilities that have already been patched, along with some basic shellcode. In my estimation, it doesn't really offer anything truly indispensable that couldn't perhaps be replaced by a simple calculator or some more standard, off-the-shelf software applications. ☕

Anthony Nguyen81 said:Perhaps it is time that we consider returning to the fundamental principles of our craft, though I suppose such a suggestion might seem somewhat regressive to some. I have been reflecting on whether our current trajectory has perhaps moved too far away from the core essentials, and I find myself wondering if a return to the basics might actually be beneficial for us all. It is a difficult thought to settle on, but maybe there is value in simplicity after all. 😬

I suppose that might turn out to be quite a bloody business, if I'm being honest. 🤣

I decided to take a little trip down memory lane just now to see how much I’ve managed to forget, and I found myself wondering if you all might recall that old riddle about the boat, the wolf, the goat, and the cabbage? 😬

I suppose you might want to keep an eye out for the sequel? 😬
I suppose I should probably mention that I’ve come across this particular document regarding the current state of affairs, though I can't say for certain how much weight one ought to give it without further context. It seems to be an analytical overview, and while I might be overthinking things, there appears to be quite a bit of data packed into these pages that could potentially influence our understanding of the situation at hand. I guess it is worth a look if you have the patience for it, even if my interpretation might be somewhat tentative.


I suppose this could be considered a laboratory assignment: I suppose there is a certain complexity surrounding the issue of jealous husbands that warrants some reflection. It seems to me that this particular dynamic can become quite heavy within a marriage, potentially creating an atmosphere of distrust that is difficult to navigate. I guess one might wonder whether such behavior stems from deep-seated insecurities or perhaps a misunderstanding of boundaries within a partnership. Maybe it isn't always about a lack of faith in one's spouse, but rather an internal struggle that the individual hasn't quite mastered yet. It feels like a delicate situation where communication often fails to bridge the gap between suspicion and security, though I realize my perspective is just one way of looking at it.
I suppose one might consider writing a program that utilizes a breadth-first search algorithm to identify an optimal path, though I imagine the specific implementation would depend quite heavily on the particular constraints of the problem at hand. It seems to me that if one were to approach this task, they would likely need to structure the logic around exploring all neighboring nodes layer by layer to ensure that the first solution encountered is indeed the most efficient one possible. Perhaps it would be wise to carefully consider how the queue is managed during the traversal, as that could ultimately determine whether the search remains performant or becomes somewhat cumbersome as the dataset grows larger.
I suppose there might be a way to address the issue of jealous husbands, though I suspect it is a rather complicated matter to unravel. Perhaps if one were to approach the situation with a great deal of patience and perhaps a bit of careful communication, a resolution might eventually emerge, though I can't say for certain how that would work in practice.
The problem could perhaps be framed in this manner: there are three husbands and their respective wives who need to...
I suppose one might attempt to cross from one side of the riverbank to the other using just a single boat. Perhaps, if one were to consider the nuances involved, it might be possible to manage such a feat, though I guess there are certainly many variables that could complicate the process.
I suppose there might come a moment where it becomes necessary to ensure that neither of the spouses is present during certain proceedings.
I suppose it might be considered appropriate to discuss a second husband, provided that her current husband isn't actually present in the conversation. A boat could potentially...
I suppose it might be best to limit the capacity to no more than two people, as I suspect the vessel simply wouldn't be able to stay afloat if it were traveling empty.
I suppose one might argue that the most optimal solution is simply the one that requires the fewest number of steps. It seems to me that a program should ideally...
Perhaps it would be best to express the solution by presenting it as a sequence consisting of both operators and states that ultimately lead to the target objective.
I suppose I should probably address the current state of things.

It seems that even a basic square root calculation would require an incredibly large number of lines of code if one were to implement it directly in Assembly. 😬

Charles Jones3 said:I suppose one might wonder what the actual purpose of using assembly would be in such a scenario. It seems to me that there are far more straightforward solutions available, so I am somewhat unsure why anyone would bother making things so unnecessarily complicated. In this day and age, assembly isn't really utilized for any meaningful development or hacking purposes anymore, as we have such a vast array of high-level programming languages at our disposal. It feels like an unnecessary struggle to spend all that mental energy breaking your head over assembly when much easier paths exist.

If you are looking to get into programming or even dive into the world of hacking, I suppose it might be enough to simply master Java and Python; perhaps Ruby and PHP could serve as secondary tools if you find they are necessary for certain tasks.

I suppose one might find themselves contemplating the intersection of Java programming and the various nuances of hacking, though I suspect such a topic could lead to an rather extreme geek debate if discussed at length. It is perhaps my belief that while Java is often viewed through the lens of enterprise stability and robust architecture, its role within the cybersecurity landscape is somewhat more complex than most people initially realize. One could argue that its managed memory environment offers certain protections, yet I guess there are still plenty of ways for vulnerabilities to manifest if the implementation isn't handled with absolute precision. 🤣

It is most frequently utilized for engineering tasks and kernel development, which leads me to wonder who might actually be in a better position to identify system vulnerabilities. I suppose one has to consider whether it is the individual relying on various JavaScript snippets to hunt for flaws, or perhaps the person capable of meticulously analyzing every single segment of a program's execution and memory allocation.

I suppose I am of the same opinion. ☕

I suppose we could relatively easily implement most of those algorithms using C or C++ if you let me know when you're ready... and once you have access to shared libraries containing various common functions, you might just need to set up a conditional jump.

Perhaps we should attempt to execute all of this directly in Assembly instead. 🍿

bluebadger112 said:Yes, I suppose that is quite true, though one could always select a value for c that is sufficiently small such that the computer simply cannot handle it, effectively recognizing it only as zero. It seems to me that even if you were to fill the entire universe with the fastest parallel processors and massive amounts of memory, you could still choose a c small enough to cause this issue.😁

That is precisely why a value like 0.0...x is treated as a natural number initially, only to be printed later as 0.0...x; it happens because the system might otherwise just perceive it as zero.

For instance, if you enter the number 12345678, a 32-bit processor would temporarily store it in a buffer.

A number of this magnitude would occupy two memory blocks.

0x00000004: 8765

0x00000008: 4321

Afterward, the values are retrieved from the buffer using a LIFO—or last in, first out—system.

Depending on whether the processor is 32-bit or 64-bit, an input like 0.0...x would result in the number being stored in memory blocks containing 4 or 8 digits respectively.

The intention when dealing with a very small c is to segment the memory blocks by increments of one rather than 4 or 8, which allows us to monitor the state of every single segment.

For example.

Let us look at the previous example.

0x00000004: 8765

0x0000008: 4321

If we were to segment these memory addresses at the smallest possible increment—that is, an offset of 1—we could track the status of the addresses, which is more useful for subsequent operations.

0x00000004: 8765

0x00000005: 7654

0x00000006: 6543

0x00000007: 5432

0x00000008: 4321

With every increase in the memory address, the input shifts one ASCII character to the left until the end of the input is reached.

In the case of a tiny c, we deal with 0.0...x. The first thing the program needs to do regarding 0.0...x is determine the "0," which is accomplished by using a cmp instruction to compare 2c (the hex value for the decimal point) with 2c; once we get zero, we execute a conditional jump to a subroutine.

Within that subroutine, we compare the values following the decimal point until we reach x.

Take 0.00000005, for example.

Once the 0 has been isolated via the cmp and the comparison of 2c, we begin analyzing the remaining 0...5.

The goal is to isolate either the final digit or the start of the first natural number at a specific decimal place, continuing all the way to the end to derive a natural number. Arithmetic operations are then performed on that number as if it were a standard natural number, and it is subsequently printed as 0.0...x.

This approach is taken specifically to prevent a situation where a computer might recognize a number with too many decimal places as being zero.

This is just one method to circumvent that particular problem. However, I suppose even then, the resulting value would be nothing more than an approximation, albeit perhaps a slightly more precise one.